多线程程序在完成之前就冻结

Question

我写了我的第一个多线程程序，并且大部分程序都能正常工作。共享缓冲区数组最初填充为-1，指示生产者其空并需要被填充。然后生产者用随机值1 - 10填充共享缓冲区，生产者轮流填充缓冲区。生产者然后向消费者发出信号，告知消费者它已经填充了缓冲区的一个元素并消耗它。生产者需要填写120个元素，每个消费者都应该填写。该程序工作完全正常，直到它到达项目110.它然后冻结，我不知道为什么。我该如何解决？

这是输出的一个片段。

Item: 85, Consuming value 8, my thread id is: 1216 
Item: 86, Consuming value 7, my thread id is: 298320 
Signal 
Producer thread 231296 and value: 0 
Producer thread 297552 and value: 2 
Producer thread 298576 and value: 0 
Item: 87, Consuming value 9, my thread id is: 297808 
Signal 
Producer thread 960 and value: 3 
Producer thread 298064 and value: 2 
Item: 88, Consuming value 3, my thread id is: 231744 
Item: 89, Consuming value 7, my thread id is: 298320 
Item: 90, Consuming value 3, my thread id is: 1216 
Item: 91, Consuming value 7, my thread id is: 298832 
Signal 
Producer thread 231296 and value: 3 
Producer thread 297552 and value: 8 
Producer thread 298576 and value: 6 
Item: 92, Consuming value 2, my thread id is: 297808 
Signal 
Producer thread 960 and value: 9 
Producer thread 298064 and value: 7 
Item: 93, Consuming value 5, my thread id is: 298320 
Item: 94, Consuming value 2, my thread id is: 298832 
Item: 95, Consuming value 0, my thread id is: 1216 
Item: 96, Consuming value 2, my thread id is: 231744 

这是我的代码

#include <stdio.h> 
#include <string.h> 
#include <unistd.h> 
#include <stdlib.h> 
#include <pthread.h> 
#include <stdint.h> 


#define THREADS 5 
#define ELEMENTS 120 


pthread_t tid_producer[THREADS], tid_consumer[THREADS]; 
int value = 0; 
int saveValue = 0; 
void *produce(void *arg); 
void *consume(void *arg); 
int producerCount =0; 
int consumerCount = ELEMENTS; 

struct { 
    pthread_mutex_t mutex; 
    int index; 
    int value; 
    int MyShBuff[ELEMENTS]; 
} add = {PTHREAD_MUTEX_INITIALIZER, 0, 0}; 


    struct{ 
    pthread_mutex_t mutex; 
    pthread_cond_t  cond; 
    int nready; 
    int value; 
    int empty; 
    int counter; 

    /* number ready for consumer */ 
} nready = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER,0, -2, ELEMENTS}; 

int main() 
{ 

    int i, j, k; 

    //Ready buffer for producers 
    for (i =0; i < ELEMENTS; i++) 
    { 
     add.MyShBuff[i]=-1; 
    } 



    for(j = 0; j < THREADS; j++) { 

    pthread_create(&tid_producer[j], NULL, &produce, NULL); 
    pthread_create(&tid_consumer[j], NULL, &consume, NULL); 
} 



/* wait for all producers and the consumer*/ 

    for(k = 0; k < THREADS; k++) { 
     pthread_join(tid_producer[k], NULL); 
     pthread_join(tid_consumer[k], NULL);  
    } 

    /* Clean up and exit */ 

    pthread_mutex_destroy(&nready.mutex); 
    pthread_mutex_destroy(&add.mutex); 
    pthread_cond_destroy(&nready.cond); 
    pthread_exit(NULL); 

    exit(0);  
    return 0; 
} 

void *produce(void *arg) 
    { 
    int i = 0; 


    for (; ;) 
    { 
     pthread_mutex_lock(&add.mutex); 
     if(add.index >= ELEMENTS) 
     { 

      pthread_mutex_unlock(&add.mutex); 
      return NULL; 
     } 
     if(add.MyShBuff[add.index] == -1) 
     { 
     add.value = rand() % 10 + 0; 
     add.MyShBuff[add.index] = add.value; 
     printf("Producer thread %d and value: %d\n" ,pthread_self(), add.MyShBuff[add.index]); 
     add.index++; 
     } 
     pthread_mutex_unlock(&add.mutex); 
     pthread_mutex_lock(&nready.mutex); 

     if(nready.nready == 0) 
     { 
     pthread_cond_broadcast(&nready.cond); 
     printf("Signal\n"); 
     } 

     nready.nready++; 
     pthread_mutex_unlock(&nready.mutex); 

     } 


    } 


void *consume(void *arg) 
{ 

pthread_mutex_lock(&nready.mutex); 

    while(nready.empty != 0) 
    { 

    while (nready.nready == 0) 
    { 


     pthread_cond_wait(&nready.cond,&nready.mutex); 


     pthread_mutex_lock(&add.mutex); 
     printf(" Item: %d, Consuming value %d, my thread id is: %d\n", nready.counter, add.MyShBuff[nready.counter], pthread_self()); 
     add.MyShBuff[nready.counter] = -2; 
     pthread_mutex_unlock(&add.mutex); 

     nready.counter++; 
     nready.empty--; 


    } 

    nready.nready--; 
    pthread_mutex_unlock(&nready.mutex); 
    } 


    return NULL; 


} 

Answer 1

正如在评论中指出，使用互斥的是错误的消耗（想象而conditon是错误的，该线程将离开不释放互斥）此外 ，我会建议限制持有相同信息的变量的数量（空，计数器），这使流程难以遵循。 最后，您的pthread_wait_cond中还存在一个错误： 请参阅Does pthread_cond_wait(&cond_t, &mutex); unlock and then lock the mutex?或解释pthread_wait_cond使用的任何其他问题：他们强调返回时谓词MAY为真，这意味着您必须在开始之前再次测试它需要谓词为真的计算。

我重写了一下你的代码以使其工作;我希望我没有错过别的东西，但可以帮助你走的更远：如果消费进入生产后等待互斥做广播

#include <stdio.h> 
#include <string.h> 
#include <unistd.h> 
#include <stdlib.h> 
#include <pthread.h> 
#include <stdint.h> 


#define THREADS 5 
#define ELEMENTS 120 


pthread_t tid_producer[THREADS], tid_consumer[THREADS]; 
int value = 0; 
int saveValue = 0; 
void *produce (void *arg); 
void *consume (void *arg); 
int producerCount = 0; 
int consumerCount = ELEMENTS; 

struct 
{ 
    pthread_mutex_t mutex; 
    int index; 
    int value; 
    int MyShBuff[ELEMENTS]; 
} add = { PTHREAD_MUTEX_INITIALIZER, 0, 0 }; 


struct 
{ 
    pthread_mutex_t mutex; 
    pthread_cond_t cond; 
    int nready; 
    int value; 
    int empty; 
    int counter; 

    /* number ready for consumer */ 
} nready = { PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, 0, -2, ELEMENTS, 0 }; 

int main(int argc, char **argv) 
{ 
    //Ready buffer for producers 
    for (int i = 0; i < ELEMENTS; i++) { 
     add.MyShBuff[i] = -1; 
    } 


    for (int j = 0; j < THREADS; j++) { 
     pthread_create (&tid_producer[j], NULL, &produce, NULL); 
     pthread_create (&tid_consumer[j], NULL, &consume, NULL); 
    } 

    /* wait for all producers and the consumer */ 
    for (int k = 0; k < THREADS; k++) { 
     pthread_join (tid_producer[k], NULL); 
     pthread_join (tid_consumer[k], NULL); 
    } 

    /* Clean up and exit */ 
    pthread_mutex_destroy (&nready.mutex); 
    pthread_mutex_destroy (&add.mutex); 
    pthread_cond_destroy (&nready.cond); 

    return 0; 
} 

void *produce(void *dummy) 
{ 
    pthread_mutex_lock (&add.mutex); 

    while (add.index < ELEMENTS) { 
     if (add.MyShBuff[add.index] == -1) 
     { 
      add.value = rand() % 10 + 0; 
      add.MyShBuff[add.index] = add.value; 
      printf("Producer thread %ld and value: %d\n" ,pthread_self(), add.MyShBuff[add.index]); 
      add.index++; 
     } 
     pthread_mutex_unlock (&add.mutex); 

     pthread_mutex_lock (&nready.mutex); 
     { 
      if (nready.nready == 0) 
      { 
       pthread_cond_broadcast (&nready.cond); 
       printf ("Signal\n"); 
      } 
      nready.nready++; 
     } 
     pthread_mutex_unlock (&nready.mutex); 

     pthread_mutex_lock (&add.mutex); 
    } 

    pthread_mutex_unlock (&add.mutex); 

    return NULL; 
} 


void *consume(void *dummy) 
{ 
    pthread_mutex_lock (&nready.mutex); 

    while (nready.empty != 0) 
    { 
     // you also need to check it is not time to leave... 
     while (nready.nready == 0 && nready.empty != 0) { 
      pthread_cond_wait (&nready.cond, &nready.mutex); 
     } 

     if (nready.empty == 0) { 
      break; 
     } 

     pthread_mutex_lock (&add.mutex); 
     printf(" Item: %d, Consuming value %d, my thread id is: %ld\n", nready.counter, add.MyShBuff[nready.counter], pthread_self()); 
     add.MyShBuff[nready.counter] = -2; 

     pthread_mutex_unlock (&add.mutex); 

     nready.counter++; 
     nready.empty--; 

     nready.nready--; 
    } 

    pthread_mutex_unlock (&nready.mutex); 

    return NULL; 
}