c语言采用线程实现读者写者问题

读者写者问题是指多个线程同时访问共享资源，其中有些线程是只读访问，有些线程是写访问，需要保证线程间的同步和互斥。在 C 语言中，可以使用线程库来实现读者写者问题。

以下是一个基于线程的读者写者问题解决方案：

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

#define MAX_READERS 5
#define MAX_WRITERS 5

pthread_mutex_t mutex;
pthread_cond_t cond_read;
pthread_cond_t cond_write;

int read_count = 0;
int write_count = 0;

void *reader(void *arg)
{
    int id = *(int*)arg;
    while (1) {
        pthread_mutex_lock(&mutex);
        while (write_count > 0) {
            pthread_cond_wait(&cond_read, &mutex);
        }
        read_count++;
        pthread_mutex_unlock(&mutex);

        printf("Reader %d is reading\n", id);
        sleep(1);

        pthread_mutex_lock(&mutex);
        read_count--;
        if (read_count == 0) {
            pthread_cond_signal(&cond_write);
        }
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

void *writer(void *arg)
{
    int id = *(int*)arg;
    while (1) {
        pthread_mutex_lock(&mutex);
        while (read_count > 0 || write_count > 0) {
            pthread_cond_wait(&cond_write, &mutex);
        }
        write_count++;
        pthread_mutex_unlock(&mutex);

        printf("Writer %d is writing\n", id);
        sleep(1);

        pthread_mutex_lock(&mutex);
        write_count--;
        pthread_cond_signal(&cond_write);
        pthread_cond_broadcast(&cond_read);
        pthread_mutex_unlock(&mutex);
    }
    return NULL;
}

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

    int i;
    int *id;

    pthread_mutex_init(&mutex, NULL);
    pthread_cond_init(&cond_read, NULL);
    pthread_cond_init(&cond_write, NULL);

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

    for (i = 0; i < MAX_WRITERS; i++) {
        id = malloc(sizeof(int));
        *id = i;
        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);
    }

    pthread_mutex_destroy(&mutex);
    pthread_cond_destroy(&cond_read);
    pthread_cond_destroy(&cond_write);

    return 0;
}

在这个例子中，我们使用了一个互斥量 `mutex` 和两个条件变量 `cond_read` 和 `cond_write` 来实现读者写者问题的同步和互斥。`read_count` 和 `write_count` 变量用来记录正在读和正在写的线程数量。读者线程在执行前需要先检查是否有写者在写入，如果有则等待条件变量 `cond_read` 的信号。如果没有写者在写入，则增加 `read_count` 计数器，执行读操作，然后减少 `read_count`。如果 `read_count` 减少为 0，说明当前没有读者，可以发送 `cond_write` 条件变量的信号，唤醒等待的写者线程。写者线程在执行前需要先检查是否有读者在读或写者在写，如果有任意一个条件成立，则等待条件变量 `cond_write` 的信号。如果没有读者和写者，则增加 `write_count` 计数器，执行写操作，然后减少 `write_count`。写者线程在完成写操作后发送 `cond_write` 的信号，唤醒等待的写者线程，同时发送 `cond_read` 的广播信号，唤醒所有等待的读者线程。

这是一个简单的读者写者问题的解决方案，你可以根据自己的需求进行修改和优化。