编写程序，使用Linux操作系统中的信号量机制模拟实现生产者-消费者问题。设有一个生产者和一个消费者，缓冲区可以存放产品，生产者不断生成产品放入缓冲区，消费者不断从缓冲区中取出产品，消费产品。编写C语言程序，使用Linux操作系统中的信号量机制模拟实现读者-写者问题。

生产者-消费者问题：
生产者-消费者问题是一个经典的同步问题，主要考察进程之间的同步和互斥。在Linux操作系统中，可以使用信号量机制实现该问题。具体实现思路是利用两个信号量表示缓冲区的状态，一个表示缓冲区中可用的产品数量，一个表示缓冲区中已经存放的产品数量。当生产者向缓冲区中放入一个产品时，需要先检查是否还有剩余的可用空间；当消费者从缓冲区中取出一个产品时，需要先检查是否还有剩余的产品可以取出。如果缓冲区中没有产品可以取出，则消费者需要等待，直到有产品可取；如果缓冲区已经满了，则生产者需要等待，直到有可用空间。

C语言程序如下：

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

#define BUFFER_SIZE 10  // 缓冲区大小
#define PRODUCT_NUM 20  // 生产者生产的产品数量

int buffer[BUFFER_SIZE];  // 缓冲区
int in = 0;  // 缓冲区写入位置
int out = 0;  // 缓冲区读取位置

sem_t mutex;  // 互斥信号量
sem_t full;  // 满缓冲区信号量
sem_t empty;  // 空缓冲区信号量

// 生产者函数
void *producer(void *arg)
{
    int i, product;

    for (i = 0; i < PRODUCT_NUM; i++) {
        product = rand() % 100;  // 随机生成产品

        sem_wait(&empty);  // 等待空缓冲区
        sem_wait(&mutex);  // 互斥锁加锁

        buffer[in] = product;
        in = (in + 1) % BUFFER_SIZE;
        printf("Producer produced product: %d\n", product);

        sem_post(&mutex);  // 互斥锁解锁
        sem_post(&full);  // 满缓冲区信号量加1
    }

    pthread_exit(NULL);
}

// 消费者函数
void *consumer(void *arg)
{
    int i, product;

    for (i = 0; i < PRODUCT_NUM; i++) {
        sem_wait(&full);  // 等待满缓冲区
        sem_wait(&mutex);  // 互斥锁加锁

        product = buffer[out];
        out = (out + 1) % BUFFER_SIZE;
        printf("Consumer consumed product: %d\n", product);

        sem_post(&mutex);  // 互斥锁解锁
        sem_post(&empty);  // 空缓冲区信号量加1
    }

    pthread_exit(NULL);
}

int main()
{
    pthread_t tid_producer, tid_consumer;

    sem_init(&mutex, 0, 1);
    sem_init(&full, 0, 0);
    sem_init(&empty, 0, BUFFER_SIZE);

    pthread_create(&tid_producer, NULL, producer, NULL);
    pthread_create(&tid_consumer, NULL, consumer, NULL);

    pthread_join(tid_producer, NULL);
    pthread_join(tid_consumer, NULL);

    sem_destroy(&mutex);
    sem_destroy(&full);
    sem_destroy(&empty);

    return 0;
}

读者-写者问题：
读者-写者问题是另一个经典的同步问题，主要考察多个进程之间对共享资源的访问。在Linux操作系统中，可以使用信号量机制实现该问题。具体实现思路是利用两个信号量表示共享资源的状态，一个表示正在读取共享资源的读者数量，一个表示正在修改共享资源的写者数量。当有读者正在读取共享资源时，其他读者可以继续读取该资源，但不能让写者修改该资源；当有写者正在修改共享资源时，其他读者和写者都不能访问该资源。

C语言程序如下：

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

#define READER_NUM 3  // 读者数量
#define WRITER_NUM 2  // 写者数量

int shared_data = 0;  // 共享资源
int reader_count = 0;  // 正在读取共享资源的读者数量

sem_t mutex;  // 访问共享资源的互斥信号量
sem_t wrt;  // 写入共享资源的信号量

// 写者函数
void *writer(void *arg)
{
    int i;

    for (i = 0; i < 5; i++) {
        sem_wait(&wrt);  // 写入共享资源信号量减1
        shared_data++;   // 修改共享资源
        printf("Writer wrote data: %d\n", shared_data);
        sem_post(&wrt);  // 写入共享资源信号量加1
        sleep(1);
    }

    pthread_exit(NULL);
}

// 读者函数
void *reader(void *arg)
{
    int i;

    for (i = 0; i < 5; i++) {
        sem_wait(&mutex);   // 访问共享资源互斥信号量减1
        reader_count++;     // 正在读取共享资源的读者数量加1
        if (reader_count == 1) {
            sem_wait(&wrt);   // 如果是第一个读者，则加锁写入共享资源的信号量
        }
        sem_post(&mutex);   // 访问共享资源互斥信号量加1

        printf("Reader read data: %d\n", shared_data);
        sleep(1);

        sem_wait(&mutex);   // 访问共享资源互斥信号量减1
        reader_count--;     // 正在读取共享资源的读者数量减1
        if (reader_count == 0) {
            sem_post(&wrt);   // 如果是最后一个读者，则解锁写入共享资源的信号量
        }
        sem_post(&mutex);   // 访问共享资源互斥信号量加1
    }

    pthread_exit(NULL);
}

int main()
{
    int i;
    pthread_t tid_reader[READER_NUM], tid_writer[WRITER_NUM];

    sem_init(&mutex, 0, 1);
    sem_init(&wrt, 0, 1);

    for (i = 0; i < WRITER_NUM; i++) {
        pthread_create(&tid_writer[i], NULL, writer, NULL);
    }
    for (i = 0; i < READER_NUM; i++) {
        pthread_create(&tid_reader[i], NULL, reader, NULL);
    }

    for (i = 0; i < WRITER_NUM; i++) {
        pthread_join(tid_writer[i], NULL);
    }
    for (i = 0; i < READER_NUM; i++) {
        pthread_join(tid_reader[i], NULL);
    }

    sem_destroy(&mutex);
    sem_destroy(&wrt);

    return 0;
}