linux+环形buffer

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

#define BUFFER_SIZE 10

typedef struct {
    int buffer[BUFFER_SIZE];
    int head;
    int tail;
    int count;
    pthread_mutex_t lock;
    pthread_cond_t not_empty;
    pthread_cond_t not_full;
} CircularBuffer;

void cb_init(CircularBuffer *cb) {
    cb->head = 0;
    cb->tail = 0;
    cb->count = 0;
    pthread_mutex_init(&cb->lock, NULL);
    pthread_cond_init(&cb->not_empty, NULL);
    pthread_cond_init(&cb->not_full, NULL);
}

void cb_push(CircularBuffer *cb, int item) {
    pthread_mutex_lock(&cb->lock);
    while (cb->count == BUFFER_SIZE) {
        pthread_cond_wait(&cb->not_full, &cb->lock);
    }
    cb->buffer[cb->head] = item;
    cb->head = (cb->head + 1) % BUFFER_SIZE;
    cb->count++;
    pthread_cond_signal(&cb->not_empty);
    pthread_mutex_unlock(&cb->lock);
}

int cb_pop(CircularBuffer *cb) {
    pthread_mutex_lock(&cb->lock);
    while (cb->count == 0) {
        pthread_cond_wait(&cb->not_empty, &cb->lock);
    }
    int item = cb->buffer[cb->tail];
    cb->tail = (cb->tail + 1) % BUFFER_SIZE;
    cb->count--;
    pthread_cond_signal(&cb->not_full);
    pthread_mutex_unlock(&cb->lock);
    return item;
}

void *producer(void *arg) {
    CircularBuffer *cb = (CircularBuffer *)arg;
    for (int i = 0; i < 20; i++) {
        cb_push(cb, i);
        printf("Produced: %d\n", i);
    }
    return NULL;
}

void *consumer(void *arg) {
    CircularBuffer *cb = (CircularBuffer *)arg;
    for (int i = 0; i < 20; i++) {
        int item = cb_pop(cb);
        printf("Consumed: %d\n", item);
    }
    return NULL;
}

int main() {
    CircularBuffer cb;
    cb_init(&cb);

    pthread_t producer_thread, consumer_thread;
    pthread_create(&producer_thread, NULL, producer, &cb);
    pthread_create(&consumer_thread, NULL, consumer, &cb);

    pthread_join(producer_thread, NULL);
    pthread_join(consumer_thread, NULL);

    return 0;
}