c语言实现读者写者

读者写者问题是多进程同步问题的一种，其中有多个读进程和一个写进程同时访问共享数据，需要保证数据的一致性和完整性。在C语言中，可以使用信号量来实现读者写者问题。

下面是一个简单的读者写者问题的实现，具体实现步骤如下：

1. 定义两个信号量，一个用于控制读进程的数量（read_mutex），一个用于控制写进程的数量（write_mutex）。

2. 定义一个计数器（counter），用于记录当前正在读取共享数据的读进程数量。

3. 在读进程中，首先尝试获取read_mutex信号量，若获取成功，则将计数器加1，然后释放read_mutex信号量，开始读取共享数据。读取完成后，再次获取read_mutex信号量，将计数器减1，如果计数器为0，则释放write_mutex信号量，允许写进程进入。最后释放read_mutex信号量。

4. 在写进程中，首先尝试获取write_mutex信号量，若获取成功，则开始写入共享数据。写入完成后，释放write_mutex信号量。

下面是代码示例：

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

#define MAX_READERS 5

int data = 0;  // 共享数据
int counter = 0;  // 当前正在读取共享数据的读进程数量

sem_t read_mutex;  // 控制读进程数量的信号量
sem_t write_mutex;  // 控制写进程数量的信号量

void *reader(void *arg) {
    int id = *(int*)arg;
    printf("Reader %d started.\n", id);
    sleep(rand() % 5);  // 随机休眠一段时间

    sem_wait(&read_mutex);  // 获取控制读进程数量的信号量
    counter++;
    if (counter == 1) {
        sem_wait(&write_mutex);  // 如果是第一个读进程，则获取控制写进程数量的信号量
    }
    sem_post(&read_mutex);  // 释放控制读进程数量的信号量

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

    sem_wait(&read_mutex);  // 获取控制读进程数量的信号量
    counter--;
    if (counter == 0) {
        sem_post(&write_mutex);  // 如果是最后一个读进程，则释放控制写进程数量的信号量
    }
    sem_post(&read_mutex);  // 释放控制读进程数量的信号量

    printf("Reader %d finished.\n", id);
    pthread_exit(NULL);
}

void *writer(void *arg) {
    int id = *(int*)arg;
    printf("Writer %d started.\n", id);
    sleep(rand() % 5);  // 随机休眠一段时间

    sem_wait(&write_mutex);  // 获取控制写进程数量的信号量

    data++;  // 写入共享数据
    printf("Writer %d wrote data: %d\n", id, data);

    sem_post(&write_mutex);  // 释放控制写进程数量的信号量

    printf("Writer %d finished.\n", id);
    pthread_exit(NULL);
}


int main() {
    // 初始化信号量
    sem_init(&read_mutex, 0, 1);
    sem_init(&write_mutex, 0, 1);

    // 创建多个读进程和一个写进程
    pthread_t readers[MAX_READERS], writer;
    int reader_ids[MAX_READERS], writer_id;
    for (int i = 0; i < MAX_READERS; i++) {
        reader_ids[i] = i;
        pthread_create(&readers[i], NULL, reader, &reader_ids[i]);
    }
    writer_id = 0;
    pthread_create(&writer, NULL, writer, &writer_id);

    // 等待所有进程结束
    for (int i = 0; i < MAX_READERS; i++) {
        pthread_join(readers[i], NULL);
    }
    pthread_join(writer, NULL);

    // 销毁信号量
    sem_destroy(&read_mutex);
    sem_destroy(&write_mutex);

    return 0;
}

在上面的示例中，我们使用了两个信号量read_mutex和write_mutex来控制读进程和写进程的数量，同时使用了一个计数器counter来记录当前正在读取共享数据的读进程数量。在读进程中，首先获取read_mutex信号量，将计数器加1，然后释放read_mutex信号量，开始读取共享数据。读取完成后，再次获取read_mutex信号量，将计数器减1，如果计数器为0，则释放write_mutex信号量，允许写进程进入。在写进程中，首先获取write_mutex信号量，然后写入共享数据，最后释放write_mutex信号量。

需要注意的是，在读进程中，每次获取read_mutex信号量后都需要释放，因为在多个读进程同时执行时，可能会出现读进程之间的竞争，如果不释放信号量，就会导致死锁。同样，在写进程中，也需要释放write_mutex信号量，否则会导致死锁。