Salve a tutti ho un problema con un esercizio di programmazione concorrente.

Ho una risorsa condivisa costituita da 5 code FIFO di messaggi con priorità crescente dall 1(più bassa) fino a 5 (più alta) e ho dei processi (nel mio caso dei thread) consumatori che verficano se nella coda con priorità più alta (5) ci sia un messaggio e eventualmente lo estraggono se no vanno a cercare in quella immeditamente più bassa e via così....se non ci sono messaggi si mettono in attesa...

evito di postare il codice della funzione estrai e l'inizializzazione dei mutex...

codice:
void *consumatore (void *my_thread_cons_arg){
 
 struct thread_cons_arg *my_arg;
 my_arg = (struct thread_cons_arg *) my_thread_cons_arg;
 int t_id = my_arg->n_thread;

 pthread_detach(pthread_self());

 printf("Thread%d\n",t_id);

  while (1){

   if(c5->n_msg>0){
        pthread_mutex_lock(&mutex5);
        printf ("Thread consumatore %d: <-\t",t_id);
        msg = estrai(c5);
        pthread_cond_signal (&ALL_FULL);
        pthread_cond_signal(&FULL5);       
        pthread_mutex_unlock(&mutex5);
       
...

   }
   else if(c4->n_msg>0){
        pthread_mutex_lock(&mutex4);
        printf ("Thread consumatore %d: <-\t",t_id);
        msg = estrai(c4);
        pthread_cond_signal (&ALL_FULL);
        pthread_cond_signal(&FULL4);
        pthread_mutex_unlock(&mutex4);
...
   }
   else if(c3->n_msg>0){
        pthread_mutex_lock(&mutex3);
        printf ("Thread consumatore %d: <-\t",t_id);
        msg = estrai(c3);
        pthread_cond_signal (&ALL_FULL);
        pthread_cond_signal(&FULL3);
        pthread_mutex_unlock(&mutex3);
...
   }
   else if(c2->n_msg>0){
        pthread_mutex_lock(&mutex2);
        printf ("Thread consumatore %d: <-\t",t_id);
        msg = estrai(c2);
        pthread_cond_signal (&ALL_FULL);
        pthread_cond_signal(&FULL2);      
        pthread_mutex_unlock(&mutex2);
...

   }
   else if(c1->n_msg>0){
        pthread_mutex_lock(&mutex1);
        printf ("Thread consumatore %d: <-\t",t_id);
        msg = estrai(c1);
         pthread_cond_signal (&ALL_FULL);
         pthread_cond_signal(&FULL1);          
         pthread_mutex_unlock(&mutex1);
...
   }
   else{
        printf("CODE VUOTE -> THREAD %d\n",t_id);
        pthread_cond_wait(&ALL_EMPTY,&m_ghost);

   }

 }
 return NULL;
}

ho definito delle variabili mutex per ogni coda che i thread consumatori(che possono essere 2 o più) devono acquisire per avere accesso alla risorsa e poi rilasciare....

alla fine ho poi definito la variabile m_ghost come mutex fantasma su cui si sospendono i thread quando tutte le code sono vuote...

questo meccanismo funziona correttamente quando ci sono diversi elementi sulle code, cioè tipicamente quando non sono vuote, infatti si assiste ad un effettiva concorrenza dei thread che in maniera ordinata processano gli elementi appartenenti alla coda di livello più alto...

quando invece le code sono vuote e un nuovo elemento viene inserito inizia a lavorare solo un thread....

mi spiego meglio....

le code sono vuote arriva un nuovo elemento nella coda 5 e viene immediatamente estratto e processato dal thread 1

se mentre l'esecuzione del thread 1 arriva un nuovo elemento nelle code mettiamo sempre sulla 5 quello che mi aspetterei è che il secondo thread rilevi la presenza del nuovo elemento e si attivi per estrarlo dalla coda e processarlo...invece quello che succede è che viene atteso che il primo thread completi le sue operazioni e poi sempre lui si incarica di estrarre e processare il nuovo elemento arrivato...il secondo thread rimane così inoperoso perdendo la concorrenza...così per ogni nuovo elemento...

Mi scuso per la lungaggine, ma spero di essermi spiegato...qualcuno ha qualche soluzione al mio problema o un approccio alternativo per affrontarla...