用C语言编写

以下是使用C语言编写的互斥双缓冲读写接口的示例代码，其中使用了pthread_mutex_t和pthread_cond_t来实现线程同步。

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

#define BUFFER_SIZE 10

// 互斥双缓冲区结构体
typedef struct {
    pthread_mutex_t mutex; // 互斥锁
    pthread_cond_t cond; // 条件变量
    int *read_buffer; // 读缓冲区指针
    int *write_buffer; // 写缓冲区指针
    size_t size; // 缓冲区大小
    int data_ready; // 数据是否准备好
    int stop; // 线程是否停止
} double_buffer;

// 初始化互斥双缓冲区
void double_buffer_init(double_buffer *db, size_t size) {
    db->read_buffer = malloc(sizeof(int) * size);
    db->write_buffer = malloc(sizeof(int) * size);
    db->size = size;
    db->data_ready = 0;
    db->stop = 0;
    pthread_mutex_init(&db->mutex, NULL);
    pthread_cond_init(&db->cond, NULL);
}

// 读取数据
void double_buffer_read(double_buffer *db, int *buffer, size_t count) {
    pthread_mutex_lock(&db->mutex); // 上锁
    while (!db->data_ready && !db->stop) { // 等待数据准备好或线程停止
        pthread_cond_wait(&db->cond, &db->mutex);
    }
    if (db->data_ready) { // 从读缓冲区复制数据
        memcpy(buffer, db->read_buffer, sizeof(int) * count);
        db->data_ready = 0;
        pthread_cond_broadcast(&db->cond);
    }
    pthread_mutex_unlock(&db->mutex); // 解锁
}

// 写入数据
void double_buffer_write(double_buffer *db, int *buffer, size_t count) {
    pthread_mutex_lock(&db->mutex); // 上锁
    while (db->data_ready && !db->stop) { // 等待数据被读取或线程停止
        pthread_cond_wait(&db->cond, &db->mutex);
    }
    if (!db->stop) { // 写入数据到写缓冲区
        memcpy(db->write_buffer, buffer, sizeof(int) * count);
        db->data_ready = 1;
        int *temp = db->read_buffer;
        db->read_buffer = db->write_buffer;
        db->write_buffer = temp; // 交换读写缓冲区指针
        pthread_cond_broadcast(&db->cond);
    }
    pthread_mutex_unlock(&db->mutex); // 解锁
}

// 停止线程
void double_buffer_stop_thread(double_buffer *db) {
    pthread_mutex_lock(&db->mutex); // 上锁
    db->stop = 1;
    pthread_cond_broadcast(&db->cond);
    pthread_mutex_unlock(&db->mutex); // 解锁
}

// 销毁互斥双缓冲区
void double_buffer_destroy(double_buffer *db) {
    free(db->read_buffer);
    free(db->write_buffer);
    pthread_mutex_destroy(&db->mutex);
    pthread_cond_destroy(&db->cond);
}

// 测试函数
void *test_double_buffer(void *arg) {
    double_buffer *db = (double_buffer *)arg;
    int buffer[BUFFER_SIZE];
    for (int i = 0; i < 100; ++i) { // 写入数据
        for (int j = 0; j < BUFFER_SIZE; ++j) {
            buffer[j] = i * BUFFER_SIZE + j;
        }
        double_buffer_write(db, buffer, BUFFER_SIZE);
        usleep(10000);
    }
    double_buffer_stop_thread(db); // 停止线程
    return NULL;
}

// 主函数
int main() {
    double_buffer db;
    double_buffer_init(&db, BUFFER_SIZE); // 初始化互斥双缓冲区
    pthread_t thread;
    pthread_create(&thread, NULL, test_double_buffer, &db); // 创建线程
    int buffer[BUFFER_SIZE];
    while (1) { // 循环读取数据
        double_buffer_read(&db, buffer, BUFFER_SIZE);
        for (int i = 0; i < BUFFER_SIZE; ++i) {
            printf("%d ", buffer[i]);
        }
        printf("\n");
        if (db.stop) {
            break;
        }
    }
    pthread_join(thread, NULL); // 等待线程结束
    double_buffer_destroy(&db); // 销毁互斥双缓冲区
    return 0;
}

该示例代码中，使用double_buffer结构体来实现互斥双缓冲区的读写功能。其中，pthread_mutex_t和pthread_cond_t用来保证线程同步，read_buffer和write_buffer分别用来保存读缓冲区和写缓冲区的数据，data_ready表示数据是否准备好，stop表示线程是否停止。在double_buffer_read函数中，线程会等待数据准备好或线程停止，然后从读缓冲区复制数据到用户缓冲区，并将data_ready标记为0，最后唤醒其他等待线程。在double_buffer_write函数中，线程会等待数据被读取或线程停止，然后将用户缓冲区的数据复制到写缓冲区，并将data_ready标记为1，然后交换读写缓冲区指针，并唤醒其他等待线程。在double_buffer_stop_thread函数中，线程会将stop标记为1，并唤醒其他等待线程，以停止线程的运行。在主函数中，通过调用double_buffer_read和double_buffer_write函数来测试双缓冲区的读写功能。