linux模拟生产者消费者

生产者消费者问题是一个经典的同步问题，可以使用Linux系统提供的信号量机制来实现。下面是一个简单的模拟生产者消费者的例子：

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

#define BUFSIZE 10

int buffer[BUFSIZE];
sem_t empty, full;
pthread_mutex_t mutex;
int in = 0, out = 0;

void *producer(void *arg) {
    int item;
    while (1) {
        item = rand() % 100;
        sem_wait(&empty);
        pthread_mutex_lock(&mutex);
        buffer[in] = item;
        in = (in + 1) % BUFSIZE;
        printf("producer produced item %d\n", item);
        pthread_mutex_unlock(&mutex);
        sem_post(&full);
        sleep(1);
    }
}

void *consumer(void *arg) {
    int item;
    while (1) {
        sem_wait(&full);
        pthread_mutex_lock(&mutex);
        item = buffer[out];
        out = (out + 1) % BUFSIZE;
        printf("consumer consumed item %d\n", item);
        pthread_mutex_unlock(&mutex);
        sem_post(&empty);
        sleep(2);
    }
}

int main() {
    pthread_t tid_producer, tid_consumer;
    sem_init(&empty, 0, BUFSIZE);
    sem_init(&full, 0, 0);
    pthread_mutex_init(&mutex, 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);
    sem_destroy(&empty);
    sem_destroy(&full);
    pthread_mutex_destroy(&mutex);
    return 0;
}

上面的代码中，`buffer` 数组表示缓冲区，`in` 表示生产者往缓冲区中写入的位置，`out` 表示消费者从缓冲区中读取的位置。`empty` 信号量表示缓冲区中空闲位置的数量，`full` 信号量表示缓冲区中已经填充的位置的数量。`mutex` 互斥锁用来保证对缓冲区的访问是互斥的。

在 `producer` 函数中，先生成一个随机数作为生产的物品，然后等待 `empty` 信号量，表示缓冲区中有空闲位置，获取到信号量后使用互斥锁访问缓冲区，将物品写入缓冲区，并更新 `in` 指针。最后释放互斥锁并发出 `full` 信号量，表示缓冲区中已经填充了一个位置。

在 `consumer` 函数中，先等待 `full` 信号量，表示缓冲区中有数据可供消费，获取到信号量后使用互斥锁访问缓冲区，读取缓冲区中的数据，并更新 `out` 指针。最后释放互斥锁并发出 `empty` 信号量，表示缓冲区中又空闲位置可供生产。

在 `main` 函数中，首先初始化信号量和互斥锁，然后创建生产者线程和消费者线程，并等待线程结束后销毁信号量和互斥锁。