Perché il mio produttore/consumatore non si sveglia? C

Question

Quindi sto lavorando a questo codice che è un codice consumatore di produttori. Funziona completamente attraverso il programma, non esegue mai nulla nella sezione critica perché non si sveglia mai veramente dal sonno! Ho aggiunto dichiarazioni di stampa ovunque per cercare di capire dove si sta eseguendo il codice ed entra sia nelle funzioni del produttore che del consumatore, ma non ne entra mai in alcuna parte dopo la funzione di sonno ().

Ecco il mio principale:

 /* 1. Get command line arguments argv[1], argv[2], argv[3] */

 /* n1=arg[2], n2=arg[3]
 /* 2. Initialize buffer, mutex, semaphores, and other global vars */

 /*create the mutex lock */
 /* create the semaphore and initialize it to 3 */
 /*creating full semaphore and initializing it to 0 */




/*** critical section ***/


 /* get the default attribute */
 pthread_attr_init(&attr);
 /* 3. Create producer thread(s) */
 while (count < n1)
   {
     pthread_t tid;
     /* create a new thread */
     pthread_create(&tid, &attr, producer, NULL);
     count++;
   }
     printf("OUTSIDE OF PRODUCER CREATION\n");
 /* 4. Create consumer thread(s) */
 count = 0;
 while(count < n2)
   {
     pthread_t tid2;
     /* create a new thread */
     pthread_create(&tid2, &attr, consumer, NULL);
     count++;
   }

 printf("after the crit section \n");
 /* 5. Sleep */
 /* 6. Realease resources, e.g destroy mutex and semaphores */

Ho incluso per la maggior parte solo il codice con cui so di avere un problema e il resto sono commenti. Ed ecco il codice per il mio produttore. Il consumatore è fondamentalmente lo stesso:

void *producer(void *param) {
    buffer_item rand;
    unsigned int *seed;
    seed = (unsigned int *)malloc(sizeof(unsigned int));
    *seed = 10;
    while (1) {
        printf("Inside producer function\n");
        /* Sleep for a random period of time */
        r = (rand_r(seed))/divide;
        sleep(r);
        printf("producer slept\n");
        //wait(empty)
       //wait(mutex)
       printf("producer locked mutex\n");
       //crit section - add item to buffer
       /*Generate a random number */
       /*insert random number*/
       printf("producer inserted item \n");
       if (resp < 0)
           printf("Producer error condition\n"); //Report error condition
       //signal mutex
       //signal empty
    }
}

Quindi quando eseguo A.out 4 4 4, ottengo questo come il mio output:

Inside producer function
Inside producer function
Inside producer function
OUTSIDE OF PRODUCER CREATION
Inside producer function
inside consumer function
inside consumer function
inside consumer function
after the crit section 
inside consumer function

Non sono sicuro che sia normale che le cose sembrino esaurire ... sta eseguendo 4 volte ma come puoi vedere se non colpisce mai quella dichiarazione di stampa che si verifica dopo la mia funzione di sonno (sia per produttore che per il consumatore)

Questo è i compiti, quindi sto solo cercando un po 'più di direzione su questo ...

Answer 1

Dalla discussione, il tuo errore era che il tuo sleep() I valori erano troppo grandi, uno che hai citato uscendo a 22 minuti. Piuttosto che divisione (/) per limitare i valori, modulo (%) metterà i tuoi valori entro un intervallo. raccomando %10, o qualche altro valore che limiterà il sonno a un intervallo ragionevole.