读者写者c语言实现

下面是一个使用互斥锁和条件变量实现读者写者问题的示例代码：

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

#define MAX_READERS 10
#define MAX_WRITERS 3

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond_read = PTHREAD_COND_INITIALIZER;
pthread_cond_t cond_write = PTHREAD_COND_INITIALIZER;

int shared_data = 0;
int readers_count = 0;

void *reader(void *arg)
{
    int id = *((int *) arg);
    while (1) {
        pthread_mutex_lock(&mutex);
        while (readers_count == -1) {
            pthread_cond_wait(&cond_read, &mutex);
        }
        readers_count++;
        pthread_mutex_unlock(&mutex);

        printf("Reader %d read shared data: %d\n", id, shared_data);

        pthread_mutex_lock(&mutex);
        readers_count--;
        if (readers_count == 0) {
            pthread_cond_signal(&cond_write);
        }
        pthread_mutex_unlock(&mutex);

        sleep(1);
    }
    return NULL;
}

void *writer(void *arg)
{
    int id = *((int *) arg);
    while (1) {
        pthread_mutex_lock(&mutex);
        while (readers_count != 0) {
            pthread_cond_wait(&cond_write, &mutex);
        }
        readers_count = -1;

        printf("Writer %d writes shared data: %d\n", id, ++shared_data);

        readers_count = 0;
        pthread_cond_broadcast(&cond_read);
        pthread_mutex_unlock(&mutex);

        sleep(1);
    }
    return NULL;
}

int main()
{
    pthread_t readers[MAX_READERS];
    pthread_t writers[MAX_WRITERS];
    int i, id;

    for (i = 0; i < MAX_READERS; i++) {
        id = i + 1;
        pthread_create(&readers[i], NULL, reader, &id);
    }

    for (i = 0; i < MAX_WRITERS; i++) {
        id = i + 1;
        pthread_create(&writers[i], NULL, writer, &id);
    }

    for (i = 0; i < MAX_READERS; i++) {
        pthread_join(readers[i], NULL);
    }

    for (i = 0; i < MAX_WRITERS; i++) {
        pthread_join(writers[i], NULL);
    }

    return 0;
}

在这个示例代码中，我们使用了一个互斥锁 `mutex` 和两个条件变量 `cond_read` 和 `cond_write`。`mutex` 用于保护共享资源 `shared_data`，避免多个写者同时修改共享资源的内容。`cond_read` 和 `cond_write` 用于同步读者和写者的访问，以确保只有一个写者在修改共享资源的内容时，其他读者和写者都被阻塞。同时，读者线程可以通过条件变量等待写者线程释放锁，以避免竞争和冲突。

在 `reader` 函数中，我们首先通过 `pthread_mutex_lock` 获取互斥锁，然后检查是否有其他写者正在修改共享资源，如果是，则调用 `pthread_cond_wait` 等待条件变量 `cond_read` 的信号通知。如果没有其他写者正在修改共享资源，则将读者计数器 `readers_count` 加 1，并释放互斥锁。接着，读者线程可以读取共享资源的内容，然后再次获取互斥锁，将读者计数器 `readers_count` 减 1，如果此时没有其他读者，则调用 `pthread_cond_signal` 发送条件变量 `cond_write` 的信号通知等待的写者线程可以开始修改共享资源了。最后，释放互斥锁，并通过 `sleep` 函数暂停一秒钟，模拟读者线程的工作。

在 `writer` 函数中，我们首先通过 `pthread_mutex_lock` 获取互斥锁，然后检查是否有其他读者正在访问共享资源，如果是，则调用 `pthread_cond_wait` 等待条件变量 `cond_write` 的信号通知。如果没有其他读者正在访问共享资源，则将读者计数器 `readers_count` 设置为 -1，表示有一个写者正在修改共享资源。接着，写者线程可以修改共享资源的内容，然后再次获取互斥锁，将读者计数器 `readers_count` 设置为 0，并通过 `pthread_cond_broadcast` 发送条件变量 `cond_read` 的信号通知所有等待的读者线程可以继续访问共享资源了。最后，释放互斥锁，并通过 `sleep` 函数暂停一秒钟，模拟写者线程的工作。

在 `main` 函数中，我们创建了多个读者线程和写者线程，并等待它们的结束。在实际运行中，读者和写者线程可能会交替运行，读者线程可以同时访问共享资源，但在任何时候只能有一个写者线程修改共享资源的内容。