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

Question

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

以下是我的代码设置方式：

#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 spaceAvailablen");
                    pthread_cond_wait(&dataAvailable,&mutex);
                    printf("Consumer: resume after the waitn");
            }
            sleep(1);
            printf("starting to empty the buffer...n");
            int j;
            for(j = 0; j < MAX; j++)
            {
                    buffer[j] = 0;
                    printf("Consumer: buffer[%d] = %dn",j,buffer[j]);
                    --count;
            }
            pthread_cond_signal(&spaceAvailable);
            printf("The value of count is: %dn",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 dataAvailablen");
                    pthread_cond_wait(&spaceAvailable,&mutex);
                    printf("Producer: resume after waitn");
            }
            sleep(1);

            printf("starting to load the buffer...n");
            int j;
            for(j = 0; j < MAX; j++)
            {
                    buffer[j] = j;
                    printf("Producer: buffer[%d] = %dn",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

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

Answer 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

只要确保你这样做，以避免任何僵局。