C语言，使用信号量解决读者-写者问题。有若干个写者线程、若干个读者线程，他们共享一个变量int data。要求：一个写者修改变量时，别人不能来读或者写；允许多个读者同时读该变量

这里给出一个使用信号量解决读者-写者问题的C语言代码示例：

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

#define READERS_NUM 5     // 读者线程数量
#define WRITERS_NUM 3     // 写者线程数量
#define READ_TIMES 3      // 每个读者线程读取次数
#define WRITE_TIMES 3     // 每个写者线程写入次数

int data = 0;             // 共享变量
sem_t rw_mutex, mutex;    // 信号量

void *reader(void *arg) {
    int id = *(int *)arg;
    int i;
    for (i = 0; i < READ_TIMES; i++) {
        sem_wait(&mutex);       // 互斥访问read_count
        int read_count;
        sem_getvalue(&rw_mutex, &read_count);
        read_count = READERS_NUM - read_count;   // 计算当前读者数量
        if (read_count == 0) {   // 如果当前没有读者，就锁住共享变量
            sem_wait(&rw_mutex);
        }
        sem_post(&mutex);

        printf("reader %d is reading data: %d\n", id, data);

        sem_wait(&mutex);       // 互斥访问read_count
        sem_getvalue(&rw_mutex, &read_count);
        read_count = READERS_NUM - read_count;   // 计算当前读者数量
        if (read_count == READERS_NUM) {   // 如果当前没有读者，就释放共享变量
            sem_post(&rw_mutex);
        }
        sem_post(&mutex);
    }
    return NULL;
}

void *writer(void *arg) {
    int id = *(int *)arg;
    int i;
    for (i = 0; i < WRITE_TIMES; i++) {
        sem_wait(&rw_mutex);     // 锁住共享变量
        printf("writer %d is writing data: %d\n", id, ++data);
        sem_post(&rw_mutex);     // 释放共享变量
    }
    return NULL;
}

int main() {
    pthread_t readers[READERS_NUM], writers[WRITERS_NUM];
    int reader_ids[READERS_NUM], writer_ids[WRITERS_NUM];
    int i;

    sem_init(&rw_mutex, 0, 1);   // 初始化读写锁，初始值为1
    sem_init(&mutex, 0, 1);      // 初始化互斥锁，初始值为1

    // 创建读者线程
    for (i = 0; i < READERS_NUM; i++) {
        reader_ids[i] = i;
        if (pthread_create(&readers[i], NULL, reader, &reader_ids[i])) {
            perror("pthread_create error");
            exit(1);
        }
    }

    // 创建写者线程
    for (i = 0; i < WRITERS_NUM; i++) {
        writer_ids[i] = i;
        if (pthread_create(&writers[i], NULL, writer, &writer_ids[i])) {
            perror("pthread_create error");
            exit(1);
        }
    }

    // 等待读者线程结束
    for (i = 0; i < READERS_NUM; i++) {
        if (pthread_join(readers[i], NULL)) {
            perror("pthread_join error");
            exit(1);
        }
    }

    // 等待写者线程结束
    for (i = 0; i < WRITERS_NUM; i++) {
        if (pthread_join(writers[i], NULL)) {
            perror("pthread_join error");
            exit(1);
        }
    }

    sem_destroy(&rw_mutex);   // 销毁读写锁
    sem_destroy(&mutex);      // 销毁互斥锁

    return 0;
}

在这个代码中，我们使用两个信号量rw_mutex和mutex来实现读写锁和互斥访问。读者线程首先获取mutex信号量，然后计算当前有多少个读者线程在读取共享变量data，如果当前没有读者线程在读取，就获取rw_mutex信号量锁住共享变量data。读取完毕后，再释放rw_mutex信号量。写者线程直接获取rw_mutex信号量，锁住共享变量data，完成修改后再释放rw_mutex信号量。