Question

#include <stdio.h>
#include <pthread.h>
#define MAX 10                                  /* maximum iterations */
int number;                                     /* the resource */
pthread_mutex_t mu= PTHREAD_MUTEX_INITIALIZER;  /* to protect the resource*/
/*
    Condition variable to signal consumer that a new number is available for
    consumption.
*/
pthread_cond_t sig_consumer= PTHREAD_COND_INITIALIZER;
/*
      Condition variable to signal the producer that
      (a) the new number has been consumed,
      (b) generate another one.
*/
pthread_cond_t sig_producer= PTHREAD_COND_INITIALIZER;
void *consumer(void *dummy)
{
      int printed= 0;
      printf("Consumer : \"Hello I am consumer #%ld. Ready to consume numbers"
             " now\"\n", pthread_self());

      while (1)
      {
         pthread_mutex_lock(&mu);
         /* Signal the producer that the consumer is ready. */
         pthread_cond_signal(&sig_producer);
         /* Wait for a new number. */
         pthread_cond_wait(&sig_consumer, &mu);
         /* Consume (print) the number. */
         printf("Consumer : %d\n", number);
         /* Unlock the mutex. */
         pthread_mutex_unlock(&mu);

         /*
           If the MAX number was the last consumed number, the consumer should
           stop.
         */
         if (number == MAX)
         {
           printf("Consumer done.. !!\n");
           break;
         }
      }
}
        /**
          @func producer
          This function is responsible for incrementing the number and signalling the
          consumer.
        */
void *producer(void *dummy)
{
      printf("Producer : \"Hello I am producer #%ld. Ready to produce numbers"
             " now\"\n", pthread_self());
      while (1)
      {
            pthread_mutex_lock(&mu);
            number ++;
            printf("Producer : %d\n", number);
            /*
              Signal the consumer that a new number has been generated for its
              consumption.
            */
            pthread_cond_signal(&sig_consumer);
            /*
              Now wait for consumer to confirm. Note, expect no confirmation for
              consumption of MAX from consumer.
            */
            if (number != MAX)
              pthread_cond_wait(&sig_producer, &mu);

            /* Unlock the mutex. */
            pthread_mutex_unlock(&mu);

            /* Stop if MAX has been produced. */
            if (number == MAX)
            {
              printf("Producer done.. !!\n");
              break;
            }
      }
}

void main()
{
      int rc, i;
      pthread_t t[2];
      number= 0;
      /* Create consumer & producer threads. */
      if ((rc= pthread_create(&t[0], NULL, consumer, NULL)))
        printf("Error creating the consumer thread..\n");
      if ((rc= pthread_create(&t[1], NULL, producer, NULL)))
        printf("Error creating the producer thread..\n");

      /* Wait for consumer/producer to exit. */
      for (i= 0; i < 2; i ++)
        pthread_join(t[i], NULL);

      printf("Done..\n");
}

问题：如果消费者线程在生产者线程之前启动，那么程序将提供预期结果，但如果生产者首先启动，则消费者将从2号开始消费;消费者无法消费数字1.即使生产者线程首先启动，如何在不引入任何其他变量或睡眠的情况下更正程序？

Answer 1

pthread_cond_t的问题在于它的名称。虽然名义上是一个“条件”，但它有没有状态 ......特别是，它根本不记得它已被发出信号 - 如果你认为它可能会被计算多少次发出信号，你会感到失望（因为你需要一个信号量）。换句话说，如果在发出信号的情况下没有pthread等待条件，则信号无效并且被遗忘。

“条件”更好地被认为是“等待队列”，其中pthreads等待某个状态更新。所以通常你有一些状态，受互斥锁的保护。如果状态不是pthread继续所需的状态，那么pthread将等待“条件”。当状态更新时，可以发信号通知“条件”。当服务员醒来时，它必须检查状态，并决定现在是否所有东西都准备好继续。

如果有两个或更多pthreads在等待，标准允许pthread_cond_signal()唤醒服务员中的一个，两个或更多或全部。互斥体确保服务员对状态的访问被序列化，但是服务员不能（通常，特别是因为这个原因）假设自信号以来状态不变。所以，写服务员很常见：

pthread_mutex_lock(&mutex) ;
....
while(...what we need to continue...)
  pthread_cond_wait(&cond, &mutex) ;
....
pthread_mutex_unlock(&mutex) ;

这反映了国家的重要性，以及“条件”的贡献程度。

生产者消费者同步11

1 个答案: