用信号量解决经典同步问题（生产者消费者问题，哲学家进餐问题）用c语言生成代码

下面是使用信号量解决生产者消费者问题和哲学家进餐问题的C语言代码：

1. 生产者消费者问题

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

#define BUFFER_SIZE 10
#define THREAD_COUNT 2

sem_t empty; // 空槽位数量
sem_t full; // 满槽位数量
pthread_mutex_t mutex; // 互斥锁

int buffer[BUFFER_SIZE]; // 缓冲区
int in = 0; // 生产者放置产品的位置
int out = 0; // 消费者取走产品的位置

void *producer(void *arg)
{
    int i, item;
    for (i = 0; i < 10; i++) {
        item = rand() % 1000;
        sem_wait(&empty); // 等待空槽位
        pthread_mutex_lock(&mutex); // 获取互斥锁
        buffer[in] = item; // 放置产品
        printf("Producer %d produced item %d in buffer slot %d\n", (int)arg, item, in);
        in = (in + 1) % BUFFER_SIZE; // 更新放置位置
        pthread_mutex_unlock(&mutex); // 释放互斥锁
        sem_post(&full); // 增加满槽位数量
    }
    pthread_exit(NULL);
}

void *consumer(void *arg)
{
    int i, item;
    for (i = 0; i < 10; i++) {
        sem_wait(&full); // 等待满槽位
        pthread_mutex_lock(&mutex); // 获取互斥锁
        item = buffer[out]; // 取走产品
        printf("Consumer %d consumed item %d from buffer slot %d\n", (int)arg, item, out);
        out = (out + 1) % BUFFER_SIZE; // 更新取走位置
        pthread_mutex_unlock(&mutex); // 释放互斥锁
        sem_post(&empty); // 增加空槽位数量
    }
    pthread_exit(NULL);
}

int main()
{
    int i;
    pthread_t threads[THREAD_COUNT];

    sem_init(&empty, 0, BUFFER_SIZE); // 初始化空槽位数量为缓冲区大小
    sem_init(&full, 0, 0); // 初始化满槽位数量为0
    pthread_mutex_init(&mutex, NULL); // 初始化互斥锁

    for (i = 0; i < THREAD_COUNT; i++) {
        if (i % 2 == 0) {
            pthread_create(&threads[i], NULL, producer, (void *)i);
        } else {
            pthread_create(&threads[i], NULL, consumer, (void *)i);
        }
    }

    for (i = 0; i < THREAD_COUNT; i++) {
        pthread_join(threads[i], NULL);
    }

    sem_destroy(&empty); // 销毁信号量
    sem_destroy(&full);
    pthread_mutex_destroy(&mutex); // 销毁互斥锁

    return 0;
}

2. 哲学家进餐问题

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

#define PHILOSOPHER_COUNT 5

sem_t chopsticks[PHILOSOPHER_COUNT]; // 筷子
pthread_mutex_t mutex; // 互斥锁

void *philosopher(void *arg)
{
    int id = (int)arg;
    int left = id;
    int right = (id + 1) % PHILOSOPHER_COUNT;
    while (1) {
        printf("Philosopher %d is thinking\n", id);
        sleep(rand() % 5); // 思考
        printf("Philosopher %d is hungry\n", id);
        sem_wait(&chopsticks[left]); // 获取左边的筷子
        sem_wait(&chopsticks[right]); // 获取右边的筷子
        pthread_mutex_lock(&mutex); // 获取互斥锁
        printf("Philosopher %d is eating\n", id);
        sleep(rand() % 3); // 进餐
        pthread_mutex_unlock(&mutex); // 释放互斥锁
        sem_post(&chopsticks[left]); // 放回左边的筷子
        sem_post(&chopsticks[right]); // 放回右边的筷子
    }
    pthread_exit(NULL);
}

int main()
{
    int i;
    pthread_t philosophers[PHILOSOPHER_COUNT];

    srand(time(NULL));

    for (i = 0; i < PHILOSOPHER_COUNT; i++) {
        sem_init(&chopsticks[i], 0, 1); // 初始化每个筷子为可用状态
    }
    pthread_mutex_init(&mutex, NULL); // 初始化互斥锁

    for (i = 0; i < PHILOSOPHER_COUNT; i++) {
        pthread_create(&philosophers[i], NULL, philosopher, (void *)i);
    }

    for (i = 0; i < PHILOSOPHER_COUNT; i++) {
        pthread_join(philosophers[i], NULL);
    }

    for (i = 0; i < PHILOSOPHER_COUNT; i++) {
        sem_destroy(&chopsticks[i]); // 销毁信号量
    }
    pthread_mutex_destroy(&mutex); // 销毁互斥锁

    return 0;
}