c或c++实现读者写者

读者写者问题是一个经典的并发控制问题，可以使用C或C++实现。以下是一种可能的实现方式：

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

#define MAX_READERS 5

int data = 0;
int reader_count = 0;
sem_t mutex, rsem;

void *writer(void *arg) {
    int val = *((int *)arg);
    
    for (int i = 0; i < 3; i++) {
        sem_wait(&mutex);
        printf("Writer %d is writing data %d\n", val, ++data);
        sem_post(&mutex);
        sleep(1);
    }
    pthread_exit(NULL);
}

void *reader(void *arg) {
    int val = *((int *)arg);
    
    for (int i = 0; i < 3; i++) {
        sem_wait(&mutex);
        reader_count++;
        if (reader_count == 1) {
            sem_wait(&rsem);
        }
        sem_post(&mutex);
        
        printf("Reader %d is reading data %d\n", val, data);
        sleep(1);
        
        sem_wait(&mutex);
        reader_count--;
        if (reader_count == 0) {
            sem_post(&rsem);
        }
        sem_post(&mutex);
    }
    pthread_exit(NULL);
}

int main() {
    pthread_t readers[MAX_READERS], writers[2];
    int reader_ids[MAX_READERS], writer_ids[2];
    
    sem_init(&mutex, 0, 1);
    sem_init(&rsem, 0, 1);
    
    for (int i = 0; i < MAX_READERS; i++) {
        reader_ids[i] = i + 1;
        pthread_create(&readers[i], NULL, reader, &reader_ids[i]);
    }
    for (int i = 0; i < 2; i++) {
        writer_ids[i] = i + 1;
        pthread_create(&writers[i], NULL, writer, &writer_ids[i]);
    }
    
    for (int i = 0; i < MAX_READERS; i++) {
        pthread_join(readers[i], NULL);
    }
    for (int i = 0; i < 2; i++) {
        pthread_join(writers[i], NULL);
    }
    
    sem_destroy(&mutex);
    sem_destroy(&rsem);
    
    return 0;
}

上述代码使用了两个信号量mutex和rsem，mutex用来保证读者和写者互斥访问共享资源data，rsem用来保证多个读者可以同时访问共享资源。

读者和写者都是一个线程，通过pthread_create函数创建。在读者线程中，先使用mutex信号量来保证读者和写者互斥访问data，然后增加reader_count计数器，判断是否是第一个读者，如果是，则使用rsem信号量来保证不会有写者同时访问data。读者访问data后，再减少reader_count计数器，如果是最后一个读者，则释放rsem信号量。

在写者线程中，也先使用mutex信号量来保证读者和写者互斥访问data，然后写入新的数据，再释放mutex信号量。

在main函数中，创建MAX_READERS个读者和2个写者线程，并等待它们完成。

需要注意的是，这个实现方式可能存在优先级反转的问题，即当读者和写者同时请求访问data时，写者可能会被阻塞，导致读者优先访问data。可以使用更高级的技术，如优先级调度，来避免这个问题。