【Linux】生产消费模型实践 --- 基于信号量的环形队列

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
#include <signal.h>
 
#define BUFFER_SIZE 10
 
int buffer[BUFFER_SIZE];
int read_pos = 0;
int write_pos = 0;
int count = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t not_full = PTHREAD_COND_INITIALIZER;
pthread_cond_t not_empty = PTHREAD_COND_INITIALIZER;
 
void handle_sigint(int sig) {
    write(1, "\n", 1);  // 打印换行
    exit(0);
}
 
void insert(int item) {
    pthread_mutex_lock(&mutex);
    while (count == BUFFER_SIZE) {
        pthread_cond_wait(&not_full, &mutex);
    }
    buffer[write_pos] = item;
    write_pos = (write_pos + 1) % BUFFER_SIZE;
    count++;
    pthread_cond_signal(&not_empty);
    pthread_mutex_unlock(&mutex);
}
 
int remove() {
    int item;
    pthread_mutex_lock(&mutex);
    while (count == 0) {
        pthread_cond_wait(&not_empty, &mutex);
    }
    item = buffer[read_pos];
    read_pos = (read_pos + 1) % BUFFER_SIZE;
    count--;
    pthread_cond_signal(&not_full);
    pthread_mutex_unlock(&mutex);
    return item;
}
 
void* producer(void* arg) {
    int i;
    for (i = 0; i < 100; i++) {
        insert(i);
        printf("Produced: %d\n", i);
        sleep(1);
    }
    return NULL;
}
 
void* consumer(void* arg) {
    int data;
    while (1) {
        data = remove();
        printf("Consumed: %d\n", data);
        sleep(2);
    }
    return NULL;
}
 
int main() {
    pthread_t producer_thread, consumer_thread;
    signal(SIGINT, handle_sigint);
    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;
}

这段代码实现了一个简单的生产者-消费者模型，其中使用了环形队列来管理数据。它定义了插入和移除操作，并且在多线程环境中安全地进行。当SIGINT信号到来时，程序优雅地退出。这个例子展示了如何使用条件变量和互斥锁来同步线程，并且如何处理UNIX信号。