如何让生产者和消费者线程连续加载和卸载共享缓冲区？答案

【问题标题】：How do I get a producer and a consumer thread to continuously load and unload a shared buffer?如何让生产者和消费者线程连续加载和卸载共享缓冲区？
【发布时间】：2014-04-14 03:44:50
【问题描述】：

我想要两个线程，一个生产者和一个消费者，它们不断地填充和清空共享缓冲区。代码有点迂腐，但我稍后将对其进行扩展以包含实际的停止条件。这是我的情况：我已经启动了生产者线程，它填充缓冲区，将控制权传递给消费者，消费者清空缓冲区。但是，消费者不会将控制权交还给生产者以重新填充缓冲区。为了让生产者和消费者线程不断地填充、清空和重新填充共享缓冲区，我必须进行哪些更改？

这是我的代码的设置方式：

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

#define MAX 10
int buffer[MAX];
int count = 0;
pthread_mutex_t mutex;
pthread_cond_t dataAvailable;
pthread_cond_t spaceAvailable;

void *consumer(void *arg)
{
    while(1)
    {
            pthread_mutex_lock(&mutex);

            while(count == 0)
            {
                    pthread_cond_signal(&spaceAvailable);
                    printf("Signaling spaceAvailable\n");
                    pthread_cond_wait(&dataAvailable,&mutex);
                    printf("Consumer: resume after the wait\n");
            }

            sleep(1);

            printf("starting to empty the buffer...\n");
            int j;
            for(j = 0; j < MAX; j++)
            {
                    buffer[j] = 0;
                    printf("Consumer: buffer[%d] = %d\n",j,buffer[j]);
                    --count;
            }

            pthread_cond_signal(&spaceAvailable);
            printf("The value of count is: %d\n",count);
            pthread_cond_wait(&dataAvailable,&mutex);

        }
}


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

            while(count == 9)
            {
                    pthread_cond_signal(&dataAvailable);
                    printf("Signaling dataAvailable\n");
                    pthread_cond_wait(&spaceAvailable,&mutex);
                    printf("Producer: resume after wait\n");
            }

            sleep(1);


            printf("starting to load the buffer...\n");
            int j;
            for(j = 0; j < MAX; j++)
            {
                    buffer[j] = j;
                    printf("Producer: buffer[%d] = %d\n",j,buffer[j]);
                    ++count;
            }

            pthread_cond_signal(&dataAvailable);

            pthread_cond_wait(&spaceAvailable,&mutex);
        }
}


int main(int argc, char *argv[])
{
    pthread_t thread;

    pthread_create(&thread,0,producer,NULL);
    pthread_create(&thread,0,consumer,NULL);
    pthread_exit(0);

}

这是我的输出的样子：

starting to load the buffer...
Producer: buffer[0] = 0
Producer: buffer[1] = 1
Producer: buffer[2] = 2
Producer: buffer[3] = 3
Producer: buffer[4] = 4
Producer: buffer[5] = 5
Producer: buffer[6] = 6
Producer: buffer[7] = 7
Producer: buffer[8] = 8
Producer: buffer[9] = 9
starting to empty the buffer...
Consumer: buffer[0] = 0
Consumer: buffer[1] = 0
Consumer: buffer[2] = 0
Consumer: buffer[3] = 0
Consumer: buffer[4] = 0
Consumer: buffer[5] = 0
Consumer: buffer[6] = 0
Consumer: buffer[7] = 0
Consumer: buffer[8] = 0
Consumer: buffer[9] = 0
The value of count is: 0

我希望每秒打印一次生产者和消费者声明。为了实现这一点，我需要解决什么问题？

【问题讨论】：

标签： c multithreading producer-consumer

【解决方案1】：

使用信号量进行同步（当一个线程执行迭代时向另一个线程发出信号）：

Semaphore s1, s2;

Producer:
P(&s1)
// do your operations
print()
V(&s2) //unlock the consumer thread

Consumer:
P(&s2)
// do your operations
print()
V(&s1) //unlock the producer thread

只要确保你这样做可以避免任何死锁。

【讨论】：

谢谢！完美运行。