Linux线程生产者消费者

在Linux中，可以使用多线程编程实现生产者消费者模型。具体实现可以使用pthread库中的线程函数和锁机制。

生产者线程的任务是不断地生产数据，并将数据存储在共享的缓冲区中。消费者线程的任务是从缓冲区中取出数据，并进行处理。

为了保证线程安全，需要使用互斥锁来控制对共享缓冲区的访问。当生产者线程往缓冲区中存入数据时，需要先获取互斥锁，完成数据存储操作后再释放锁。同样，当消费者线程从缓冲区中取出数据时也需要获取互斥锁。

当缓冲区满时，生产者线程需要等待消费者线程取走一部分数据后再继续生产。这可以使用条件变量来实现。生产者线程在往缓冲区中存储数据时，如果缓冲区已满，则等待条件变量。当消费者线程取出一部分数据后，会唤醒生产者线程，继续进行生产。

同样，当缓冲区为空时，消费者线程需要等待生产者线程生产数据后再进行消费。这可以使用另一个条件变量来实现。当消费者线程从缓冲区中取出数据时，如果缓冲区为空，则等待条件变量。当生产者线程往缓冲区中存储数据后，会唤醒消费者线程，继续进行消费。

下面是一个简单的Linux线程生产者消费者模型的示例代码：

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

#define BUFFER_SIZE 10
#define PRODUCER_NUM 3
#define CONSUMER_NUM 2

int buffer[BUFFER_SIZE];
int count = 0;

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t buffer_not_empty = PTHREAD_COND_INITIALIZER;
pthread_cond_t buffer_not_full = PTHREAD_COND_INITIALIZER;

void *producer(void *arg) {
    int id = *((int*)arg);
    while (1) {
        pthread_mutex_lock(&mutex);
        if (count == BUFFER_SIZE) {
            pthread_cond_wait(&buffer_not_full, &mutex);
        }
        buffer[count++] = id;
        printf("producer %d produce one item, count=%d\n", id, count);
        pthread_cond_signal(&buffer_not_empty);
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
    return NULL;
}

void *consumer(void *arg) {
    int id = *((int*)arg);
    while (1) {
        pthread_mutex_lock(&mutex);
        if (count == 0) {
            pthread_cond_wait(&buffer_not_empty, &mutex);
        }
        int item = buffer[--count];
        printf("consumer %d consume one item, count=%d\n", id, count);
        pthread_cond_signal(&buffer_not_full);
        pthread_mutex_unlock(&mutex);
        sleep(1);
    }
    return NULL;
}

int main() {
    pthread_t producer_threads[PRODUCER_NUM];
    pthread_t consumer_threads[CONSUMER_NUM];
    int i, rc;
    int producer_ids[PRODUCER_NUM];
    int consumer_ids[CONSUMER_NUM];
    for (i = 0; i < PRODUCER_NUM; i++) {
        producer_ids[i] = i + 1;
        rc = pthread_create(&producer_threads[i], NULL, producer, &producer_ids[i]);
        if (rc != 0) {
            fprintf(stderr, "producer %d create failed\n", i + 1);
            exit(1);
        }
    }
    for (i = 0; i < CONSUMER_NUM; i++) {
        consumer_ids[i] = i + 1;
        rc = pthread_create(&consumer_threads[i], NULL, consumer, &consumer_ids[i]);
        if (rc != 0) {
            fprintf(stderr, "consumer %d create failed\n", i + 1);
            exit(1);
        }
    }
    for (i = 0; i < PRODUCER_NUM; i++) {
        pthread_join(producer_threads[i], NULL);
    }
    for (i = 0; i < CONSUMER_NUM; i++) {
        pthread_join(consumer_threads[i], NULL);
    }
    return 0;
}

在上述代码中，生产者线程的数量为3，消费者线程的数量为2，缓冲区大小为10。生产者线程会不断地往缓冲区中存储数据，消费者线程会不断地从缓冲区中取出数据，直到线程被中止。

运行上述代码，可以看到生产者线程和消费者线程交替执行，并正确地实现了生产者消费者模型。