用C语言实现读者写者问题

读者写者问题是一个经典的并发控制问题，其中多个进程（或线程）共享一个资源。在该问题中，有多个读进程和多个写进程，它们共享一个资源，但是只有一个写进程可以访问该资源，而读进程可以并发访问该资源。

以下是一个使用C语言实现读者写者问题的示例代码：

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

#define READERS_COUNT 5
#define WRITERS_COUNT 2

pthread_mutex_t mutex; // 互斥锁
pthread_cond_t can_read; // 读者条件变量
pthread_cond_t can_write; // 写者条件变量

int readers = 0; // 当前读者数量
int writers = 0; // 当前写者数量
int resource = 0; // 共享资源

void *reader(void *arg) {
    int id = *(int *) arg;
    while (1) {
        pthread_mutex_lock(&mutex);
        while (writers > 0) { // 如果有写者正在访问资源，则等待
            pthread_cond_wait(&can_read, &mutex);
        }
        readers++; // 增加当前读者数量
        printf("Reader %d reads resource %d\n", id, resource);
        readers--; // 减少当前读者数量
        if (readers == 0) { // 如果没有读者了，则唤醒写者
            pthread_cond_signal(&can_write);
        }
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

void *writer(void *arg) {
    int id = *(int *) arg;
    while (1) {
        pthread_mutex_lock(&mutex);
        while (writers > 0 || readers > 0) { // 如果有读者或者写者正在访问资源，则等待
            pthread_cond_wait(&can_write, &mutex);
        }
        writers++; // 增加当前写者数量
        resource++; // 修改共享资源
        printf("Writer %d writes resource %d\n", id, resource);
        writers--; // 减少当前写者数量
        pthread_cond_signal(&can_write); // 唤醒其他写者
        pthread_cond_broadcast(&can_read); // 唤醒所有读者
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

int main() {
    pthread_t readers[READERS_COUNT];
    pthread_t writers[WRITERS_COUNT];
    int reader_ids[READERS_COUNT];
    int writer_ids[WRITERS_COUNT];
    int i;

    pthread_mutex_init(&mutex, NULL); // 初始化互斥锁
    pthread_cond_init(&can_read, NULL); // 初始化读者条件变量
    pthread_cond_init(&can_write, NULL); // 初始化写者条件变量

    // 创建读者线程
    for (i = 0; i < READERS_COUNT; i++) {
        reader_ids[i] = i;
        pthread_create(&readers[i], NULL, reader, &reader_ids[i]);
    }

    // 创建写者线程
    for (i = 0; i < WRITERS_COUNT; i++) {
        writer_ids[i] = i;
        pthread_create(&writers[i], NULL, writer, &writer_ids[i]);
    }

    // 等待所有线程结束
    for (i = 0; i < READERS_COUNT; i++) {
        pthread_join(readers[i], NULL);
    }
    for (i = 0; i < WRITERS_COUNT; i++) {
        pthread_join(writers[i], NULL);
    }

    pthread_mutex_destroy(&mutex); // 销毁互斥锁
    pthread_cond_destroy(&can_read); // 销毁读者条件变量
    pthread_cond_destroy(&can_write); // 销毁写者条件变量

    return 0;
}

在这个例子中，我们使用一个互斥锁来保护共享资源，使用两个条件变量来控制读者和写者的访问。读者线程和写者线程轮流访问共享资源，并在访问前和访问后使用条件变量进行等待和唤醒。这样就能够保证读者和写者的并发访问，并且不会出现竞争条件。