Warum wacht mein Produzent/Verbraucher nicht auf? C

Question

Ich arbeite also an diesem Code, der ein Produzenten-Verbraucher-Code ist. Es läuft vollständig durch das Programm, es wird im kritischen Abschnitt einfach nie etwas ausgeführt, weil es nie wirklich aus dem Schlaf aufwacht! Ich habe überall Druckanweisungen hinzugefügt, um herauszufinden, wo der Code ausgeführt wird, und er tritt sowohl Produzenten- als auch Verbraucherfunktionen ein, tritt jedoch nach der Sleep () -Funktion nie einen Teil davon ein.

Hier ist mein Haupt:

 /* 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 */

Ich habe größtenteils nur den Code aufgenommen, von dem ich weiß, dass ich ein Problem habe, und der Rest sind Kommentare. Und hier ist der Code für meinen Produzenten. Der Verbraucher ist im Grunde der gleiche:

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
    }
}

Wenn ich also A.OUT 4 4 4 laufe, bekomme ich dies als meine Ausgabe:

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

Ich bin mir nicht sicher, ob es normal ist, dass die Dinge so aussehen, als wären sie nicht in der Reihenfolge ... es wird 4 Mal ausgeführt, aber wie Sie sehen können, ob diese Druckanweisung niemals nach meiner Schlaffunktion trifft (sowohl für den Produzenten als auch für den Verbraucher).

Dies sind Hausaufgaben, also suche ich nur noch nach etwas mehr Richtung ...

Answer 1

Aus der Diskussion war Ihr Fehler, dass Ihre sleep() Die Werte waren zu groß, eine, die Sie bis zu 22 Minuten zitierten. Eher als Teilung (/) Um die Werte zu begrenzen, Modulo (%) stellt Ihre Werte in einen Bereich. Ich empfehle %10, oder ein anderer Wert, der den Schlaf auf einen angemessenen Bereich beschränkt.