Linux消费者生产同步问题代码实现

Linux下的生产者消费者模型可以使用pthread库中的互斥锁和条件变量来实现同步。下面是一个简单的生产者消费者模型的示例代码：

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

#define BUFFER_SIZE 10

int buffer[BUFFER_SIZE];
int in = 0, out = 0;
int count = 0;

pthread_mutex_t mutex;
pthread_cond_t not_full;
pthread_cond_t not_empty;

void *producer(void *arg);
void *consumer(void *arg);

int main()
{
    pthread_t tid_producer, tid_consumer;

    // 初始化互斥锁和条件变量
    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&not_full, NULL);
    pthread_cond_init(&not_empty, NULL);

    // 创建生产者和消费者线程
    pthread_create(&tid_producer, NULL, producer, NULL);
    pthread_create(&tid_consumer, NULL, consumer, NULL);

    // 等待线程结束
    pthread_join(tid_producer, NULL);
    pthread_join(tid_consumer, NULL);

    // 销毁互斥锁和条件变量
    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&not_full);
    pthread_cond_destroy(&not_empty);

    return 0;
}

void *producer(void *arg)
{
    while (1) {
        pthread_mutex_lock(&mutex);
        if (count == BUFFER_SIZE) {
            // 缓冲区已满，等待消费者消费
            pthread_cond_wait(&not_full, &mutex);
        }

        // 生产者生产一个数据，并将其放入缓冲区
        int item = rand() % 100;
        buffer[in] = item;
        in = (in + 1) % BUFFER_SIZE;
        count++;

        printf("producer: produce item %d, buffer count = %d\n", item, count);

        // 通知消费者可以消费了
        pthread_cond_signal(&not_empty);

        pthread_mutex_unlock(&mutex);
    }
}

void *consumer(void *arg)
{
    while (1) {
        pthread_mutex_lock(&mutex);
        if (count == 0) {
            // 缓冲区为空，等待生产者生产
            pthread_cond_wait(&not_empty, &mutex);
        }

        // 消费者消费一个数据，并从缓冲区中删除
        int item = buffer[out];
        out = (out + 1) % BUFFER_SIZE;
        count--;

        printf("consumer: consume item %d, buffer count = %d\n", item, count);

        // 通知生产者可以生产了
        pthread_cond_signal(&not_full);

        pthread_mutex_unlock(&mutex);
    }
}

在上述代码中，生产者线程每次生产一个数据并将其放入缓冲区，如果缓冲区已满，则等待消费者消费；消费者线程每次从缓冲区中取出一个数据并将其消费，如果缓冲区为空，则等待生产者生产。使用互斥锁保证在访问共享资源时不会出现竞争条件，使用条件变量实现生产者和消费者之间的同步。