1.
生产者消费者问题
生产者消费者问题是一种
经典的
同步问题，其中
生产者线程将数据添加到共享缓冲区中，而
消费者线程从该缓冲区中获取数据。为了避免竞争条件和死锁，我们需要使用信号量来解决这个
问题。
使用
两个信号量，一个用于表示缓冲区是否为空，另一个用于表示缓冲区是否已满。当缓冲区已满时，
生产者将等待，直到缓冲区不再满。当缓冲区为空时，
消费者将等待，直到缓冲区中有更多数据。
以下是用信号量解决
生产者消费者问题的示例
代码：
```c
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#define BUFFER_SIZE 10
int buffer[BUFFER_SIZE];
sem_t empty, full;
int in = 0, out = 0;
void *producer(void *arg) {
int item;
while (1) {
item = rand() % 100;
sem_wait(&empty);
buffer[in] = item;
printf("Producer produced item %d at %d\n", item, in);
in = (in + 1) % BUFFER_SIZE;
sem_post(&full);
}
}
void *consumer(void *arg) {
int item;
while (1) {
sem_wait(&full);
item = buffer[out];
printf("Consumer consumed item %d at %d\n", item, out);
out = (out + 1) % BUFFER_SIZE;
sem_post(&empty);
}
}
int main() {
sem_init(&empty, 0, BUFFER_SIZE);
sem_init(&full, 0, 0);
pthread_t producer_thread, consumer_thread;
pthread_create(&producer_thread, NULL, producer, NULL);
pthread_create(&consumer_thread, NULL, consumer, NULL);
pthread_join(producer_thread, NULL);
pthread_join(consumer_thread, NULL);
sem_destroy(&empty);
sem_destroy(&full);
return 0;
}
```
2.
哲学家进餐
问题
哲学家进餐
问题是一个
经典的
同步问题，其中有五个
哲学家围坐在圆桌旁，每个
哲学家需要交替地思考和进餐。他们之间共享五个叉子，每个
哲学家需要
两个叉子才能进餐。
使用信号量来解决
哲学家进餐
问题。每个叉子都有一个信号量，当
哲学家想要使用叉子时，他必须先获取左边的叉子，然后获取右边的叉子。当
哲学家用完叉子时，他将释放
两个叉子的信号量。
以下是用信号量解决
哲学家进餐
问题的示例
代码：
```c
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#define NUM_PHILOSOPHERS 5
sem_t forks[NUM_PHILOSOPHERS];
pthread_mutex_t mutex;
void *philosopher(void *arg) {
int id = *(int *)arg;
int left = id;
int right = (id + 1) % NUM_PHILOSOPHERS;
while (1) {
// think
printf("Philosopher %d is thinking\n", id);
sleep(rand() % 3);
// pick up forks
pthread_mutex_lock(&mutex);
sem_wait(&forks[left]);
sem_wait(&forks[right]);
pthread_mutex_unlock(&mutex);
printf("Philosopher %d is eating\n", id);
sleep(rand() % 3);
// put down forks
sem_post(&forks[left]);
sem_post(&forks[right]);
}
}
int main() {
int ids[NUM_PHILOSOPHERS];
pthread_t philosophers[NUM_PHILOSOPHERS];
pthread_mutex_init(&mutex, NULL);
for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
sem_init(&forks[i], 0, 1);
ids[i] = i;
pthread_create(&philosophers[i], NULL, philosopher, &ids[i]);
}
for (int i = 0; i < NUM_PHILOSOPHERS; i++) {
pthread_join(philosophers[i], NULL);
sem_destroy(&forks[i]);
}
pthread_mutex_destroy(&mutex);
return 0;
}
```
3.
读者写者问题
读者写者问题是一个
经典的
同步问题，其中有多个
读者和
写者同时访问共享资源。多个
读者可以同时读取共享资源，但是只有一个
写者可以写入共享资源。当
写者正在写入共享资源时，其他
读者和
写者都需要等待。
使用信号量来解决
读者写者问题。使用
两个信号量，一个用于表示共享资源是否正在被写入，另一个用于表示
读者数量。当
写者正在写入共享资源时，所有请求访问共享资源的
读者和
写者都需要等待。当有
读者正在读取共享资源时，所有
写者都需要等待。当没有
写者正在写入共享资源并且没有
读者正在读取共享资源时，
写者可以开始写入共享资源。
以下是用信号量解决
读者写者问题的示例
代码：
```c
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#define NUM_READERS 5
#define NUM_WRITERS 2
int shared_resource = 0;
sem_t resource_mutex, read_mutex;
int num_readers = 0;
void *reader(void *arg) {
while (1) {
sem_wait(&read_mutex);
num_readers++;
if (num_readers == 1) {
sem_wait(&resource_mutex);
}
sem_post(&read_mutex);
printf("Reader read value %d\n", shared_resource);
sleep(rand() % 3);
sem_wait(&read_mutex);
num_readers--;
if (num_readers == 0) {
sem_post(&resource_mutex);
}
sem_post(&read_mutex);
}
}
void *writer(void *arg) {
while (1) {
sem_wait(&resource_mutex);
printf("Writer wrote value %d\n", ++shared_resource);
sleep(rand() % 3);
sem_post(&resource_mutex);
}
}
int main() {
pthread_t readers[NUM_READERS], writers[NUM_WRITERS];
sem_init(&resource_mutex, 0, 1);
sem_init(&read_mutex, 0, 1);
for (int i = 0; i < NUM_READERS; i++) {
pthread_create(&readers[i], NULL, reader, NULL);
}
for (int i = 0; i < NUM_WRITERS; i++) {
pthread_create(&writers[i], NULL, writer, NULL);
}
for (int i = 0; i < NUM_READERS; i++) {
pthread_join(readers[i], NULL);
}
for (int i = 0; i < NUM_WRITERS; i++) {
pthread_join(writers[i], NULL);
}
sem_destroy(&resource_mutex);
sem_destroy(&read_mutex);
return 0;
}
```
最低0.47元/天 解锁文章
401
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
