Linux下模拟实现生产者-消费者问题

生产者-消费者问题是一个经典的同步问题，涉及到多个线程之间的协作，需要保证生产者和消费者之间的生产和消费过程是互相协调和同步的。在Linux环境下，可以使用pthread库来实现多线程的同步和互斥。

下面是一种基本的生产者-消费者问题的模拟实现，使用了一个生产者线程和一个消费者线程，并且使用了一个共享的缓冲区来存储生产者生产的数据和消费者消费的数据。

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

#define BUFFER_SIZE 10

int buffer[BUFFER_SIZE];
int count = 0;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t producer_cond = PTHREAD_COND_INITIALIZER;
pthread_cond_t consumer_cond = PTHREAD_COND_INITIALIZER;

void *producer(void *arg)
{
    int i, j;
    for (i = 0; i < 20; i++) {
        pthread_mutex_lock(&mutex);
        if (count >= BUFFER_SIZE) {
            pthread_cond_wait(&producer_cond, &mutex);
        }
        buffer[count] = i;
        count++;
        printf("Producer produced %d\n", i);
        pthread_cond_signal(&consumer_cond);
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
    return NULL;
}

void *consumer(void *arg)
{
    int i, j;
    for (i = 0; i < 20; i++) {
        pthread_mutex_lock(&mutex);
        if (count <= 0) {
            pthread_cond_wait(&consumer_cond, &mutex);
        }
        int data = buffer[count-1];
        count--;
        printf("Consumer consumed %d\n", data);
        pthread_cond_signal(&producer_cond);
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
    return NULL;
}

int main()
{
    pthread_t producer_thread, consumer_thread;
    pthread_create(&producer_thread, NULL, producer, NULL);
    pthread_create(&consumer_thread, NULL, consumer, NULL);
    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);
    return 0;
}

在这个例子中，我们使用了一个长度为10的缓冲区来存储生产者生产的数据和消费者消费的数据。在生产者线程中，我们使用了一个循环来不断地生产数据，并且在缓冲区已满的情况下，使用pthread_cond_wait函数来等待消费者线程消费数据，同时释放锁。在消费者线程中，我们也使用了一个循环来不断地消费数据，并且在缓冲区为空的情况下，使用pthread_cond_wait函数来等待生产者线程生产数据，同时释放锁。在生产者线程生产了数据之后，我们使用pthread_cond_signal函数来唤醒消费者线程；在消费者线程消费了数据之后，我们使用pthread_cond_signal函数来唤醒生产者线程。

需要注意的是，在使用pthread_cond_wait函数等待条件变量的时候，需要先获取互斥锁，然后在等待条件变量时释放互斥锁。这样可以保证在等待条件变量的时候，其他线程可以获取到互斥锁并访问共享资源。同时，在发送条件变量通知的时候，也需要先获取互斥锁，然后发送通知，最后释放互斥锁。这样可以保证在通知其他线程之前，当前线程已经完成了对共享资源的访问，避免多个线程同时访问同一个共享资源的情况。