c - 我如何确保生产者线程和消费者线程都一个接一个地无限运行？

Question

如何确保 Producer 和 Consumer 函数都无限且一个接一个地运行？例如:首先，我希望用户输入数组，然后消费者函数打印输入的数组，然后再次要求用户输入数组。

/*  Headers  */


pthread_mutex_t mutex;
pthread_cond_t cond,cond1;
void *producer(void *arg);
void *consumer(void *arg);
static int n;
int consumerFlag[100];

void *producer(void *arg) 
{

  pthread_mutex_lock(&mutex);        

  while(1)
    {
      printf("\n Enter no of terms");
      scanf("%d",&n);
      int i; 
      printf("\n Enter consumer flag array");
      for (i = 0; i < n; i++) 
        {
      scanf(" %d",&consumerFlag[i]);
      pthread_mutex_unlock(&mutex);           
        }
      pthread_cond_signal(&cond);    
      usleep(1000);
    }


}


void *consumer(void *arg) 
{
  int i;
  pthread_mutex_lock(&mutex);
  pthread_cond_wait(&cond, &mutex); 
  printf("\nConsumer Function"); 
  while(1)
    {

      printf("\nConsumer thread waiting"); 

      for (i = 0; i < n; i++) 
        {    
          printf("\nConsumerFlag %d = %d", i, consumerFlag[i]); 
          pthread_mutex_unlock(&mutex);         

        }          

    }

}

int main()
{
  int i=0;
  pthread_mutex_init(&mutex,0);
  pthread_cond_init(&cond,0);   
  pthread_t pThread, cThread;
  pthread_create(&pThread, 0, producer, 0);
  pthread_create(&cThread, 0, consumer,0);   
  pthread_join(pThread,NULL);
  pthread_join(cThread, NULL);
  pthread_mutex_destroy(&mutex);
  pthread_cond_destroy(&cond);
  return 0;
}

首先，我希望用户输入数组，然后消费者函数打印输入的数组，然后再次要求用户输入数组。

Answer 1

您的代码中几乎没有重大问题。

1. 只有在线程之前锁定了它的情况下，线程才能解锁互斥量。在您的代码中，互斥锁在循环函数外部锁定并在循环内部解锁。它将给出未定义的行为。
2. 消费者函数在进入循环之前执行 signal_wait()。我认为您假设生产者和消费者线程几乎同时启动，并且生产者不会在消费者锁定互斥锁之前发出信号。这是错误的。 您应该假设线程以随机顺序安排并处理所有可能的情况。
3. 当消费者完全使用数据时，您不会通知生产者。没有从消费者到生产者的信号机制。
4. 当生产者完全生产数据时，您会通知消费者。但是消费者并没有在 while 循环之外等待。这意味着，只有一次它可能会收到通知。
5. 在producer中，condition_signal是在unlock mutex之后，这是错误的。应在锁定互斥量的情况下调用信号。

所以在生产者中，需要生产数据，发送信号给消费者，等待消费者确认数据被消费。您需要另外设置一个标志，以考虑生产者线程在消费者线程之前获取锁的情况。在这种情况下，消费者不会在生产者发送信号时进入 while 循环。所以消费者无法捕捉到信号。

void *producer(void *arg) 
{     
    pthread_mutex_lock(&mutex);        

    while(1)
    {
        printf("\n Enter no of terms");
        scanf("%d",&n);
        int i; 
        printf("\n Enter consumer flag array");
        for (i = 0; i < n; i++) 
        {
            scanf(" %d",&consumerFlag[i]);
            //pthread_mutex_unlock(&mutex);  //Should not be unlocked in loop         
        }
        data_produced_flag = 1; //A flag to indicate data is ready. Should be initialized to 0 before thread creation. It is required if producer produces before consumer thread goes to pthread_cond_wait()
        pthread_cond_signal(&cond_producer); //Should send signal with mutex locked
        //usleep(1000); //Not required as it is going to wait for signal from consumer

        pthread_cond_wait(&cond_consumer, &mutex); //Wait for confirmation that data is consumed
    }
    pthread_mutex_unlock(&mutex); 
}

在消费者函数中，您应该检查数据是否已经产生。如果没有生产，等待生产者的信号。当数据可用时，消费并向生产者发出信号以获取新数据。

void *consumer(void *arg) 
{
    int i;
    pthread_mutex_lock(&mutex);
    //pthread_cond_wait(&cond, &mutex);  //Wait inside loop
    printf("\nConsumer Function"); 
    while(1)
    {
        if(0 == data_produced_flag) 
        {
            printf("\nConsumer thread waiting"); 
            pthread_cond_wait(&cond_producer, &mutex); //Wait for signal from producer
        }
        //else
        //{
            //Data is already produced. No need to wait.
        //}

        //Data is available for consumption
        for (i = 0; i < n; i++) 
        {    
            printf("\nConsumerFlag %d = %d", i, consumerFlag[i]); 
            //pthread_mutex_unlock(&mutex);    //We are in the process of consumption. Don't unlock mutex.
        }
        data_produced_flag = 0; //Reset the flag. Ready for new data.
        pthread_cond_signal(&cond_consumer); //Indicate that data is consumed
    }
    pthread_mutex_unlock(&mutex); 
}