以下是C语言实现
读者写者问题的代码，使用信号量机制：
引用:使用POSIX信号量机制解决
读者-
写者问题C语言实现，
读者和
写者进程数量可设置。[^1]
```c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <fcntl.h>
#include <semaphore.h>
#include <sys/mman.h>
#define FILE_MODE (S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)
// 全局变量
static sem_t *r_lock; //
读者锁
static sem_t *rw_lock; //
写者锁
static int *read_cnt; //
读者数量计数器
static int *data; // 共享数据区
//
读者线程
void *reader(void *arg) {
int id = *(int *)arg;
while (1) {
//
读者锁
加锁
sem_wait(r_lock);
(*read_cnt)++;
if (*read_cnt == 1) {
sem_wait(rw_lock);
}
//
读者锁解锁
sem_post(r_lock);
// 读取数据
printf("Reader %d is reading data: %d\n", id, *data);
//
读者锁
加锁
sem_wait(r_lock);
(*read_cnt)--;
if (*read_cnt == 0) {
sem_post(rw_lock);
}
//
读者锁解锁
sem_post(r_lock);
// 等待一段时间
sleep(rand() % 3 + 1);
}
return NULL;
}
//
写者线程
void *writer(void *arg) {
int id = *(int *)arg;
while (1) {
//
写者锁
加锁
sem_wait(rw_lock);
// 写入数据
(*data)++;
printf("Writer %d is writing data: %d\n", id, *data);
//
写者锁解锁
sem_post(rw_lock);
// 等待一段时间
sleep(rand() % 3 + 1);
}
return NULL;
}
int main(int argc, char *argv[]) {
// 获取参数
if (argc != 3) {
printf("usage: %s <reader_num> <writer_num>\n", argv);
exit(1);
}
int reader_num = atoi(argv);
int writer_num = atoi(argv);
// 创建共享内存
int fd = shm_open("/shm", O_CREAT | O_RDWR, FILE_MODE);
ftruncate(fd, sizeof(sem_t) * 2 + sizeof(int) * 2);
r_lock = mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
rw_lock = mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE, MAP_SHARED, fd, sizeof(sem_t));
read_cnt = mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, fd, sizeof(sem_t) * 2);
data = mmap(NULL, sizeof(int), PROT_READ | PROT_WRITE, MAP_SHARED, fd, sizeof(sem_t) * 2 + sizeof(int));
// 初始化信号量
sem_init(r_lock, 1, 1);
sem_init(rw_lock, 1, 1);
// 创建
读者线程
pthread_t tid[reader_num + writer_num];
int index = 0;
for (int i = 0; i < reader_num; i++) {
int *id = malloc(sizeof(int));
*id = ++index;
pthread_create(&tid[i], NULL, reader, id);
}
// 创建
写者线程
for (int i = 0; i < writer_num; i++) {
int *id = malloc(sizeof(int));
*id = ++index;
pthread_create(&tid[reader_num + i], NULL, writer, id);
}
// 等待线程结束
for (int i = 0; i < reader_num + writer_num; i++) {
pthread_join(tid[i], NULL);
}
// 销毁信号量
sem_destroy(r_lock);
sem_destroy(rw_lock);
// 删除共享内存
munmap(r_lock, sizeof(sem_t));
munmap(rw_lock, sizeof(sem_t));
munmap(read_cnt, sizeof(int));
munmap(data, sizeof(int));
shm_unlink("/shm");
return 0;
}
```
引用:使用System V信号量机制解决
读者-
写者问题C语言实现，
读者和
写者进程数量可设置。
```c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>
#include <sys/sem.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
// 定义信号量操作
static struct sembuf sem_r_lock = {
{0, 0, SEM_UNDO},
{0, 1, SEM_UNDO},
};
static struct sembuf sem_r_unlock = {
{0, -1, SEM_UNDO},
};
static struct sembuf sem_rw_lock = {
{1, 0, SEM_UNDO},
{0, 0, SEM_UNDO},
};
static struct sembuf sem_rw_unlock = {
{1, -1, SEM_UNDO},
};
// 全局变量
static int sem_id; // 信号量ID
static int *read_cnt; //
读者数量计数器
static int *data; // 共享数据区
//
读者线程
void *reader(void *arg) {
int id = *(int *)arg;
while (1) {
//
读者锁
加锁
semop(sem_id, sem_r_lock, 2);
(*read_cnt)++;
if (*read_cnt == 1) {
semop(sem_id, sem_rw_lock, 2);
}
//
读者锁解锁
semop(sem_id, sem_r_unlock, 1);
// 读取数据
printf("Reader %d is reading data: %d\n", id, *data);
//
读者锁
加锁
semop(sem_id, sem_r_lock, 2);
(*read_cnt)--;
if (*read_cnt == 0) {
semop(sem_id, sem_rw_unlock, 1);
}
//
读者锁解锁
semop(sem_id, sem_r_unlock, 1);
// 等待一段时间
sleep(rand() % 3 + 1);
}
return NULL;
}
//
写者线程
void *writer(void *arg) {
int id = *(int *)arg;
while (1) {
//
写者锁
加锁
semop(sem_id, sem_rw_lock, 2);
// 写入数据
(*data)++;
printf("Writer %d is writing data: %d\n", id, *data);
//
写者锁解锁
semop(sem_id, sem_rw_unlock, 1);
// 等待一段时间
sleep(rand() % 3 + 1);
}
return NULL;
}
int main(int argc, char *argv[]) {
// 获取参数
if (argc != 3) {
printf("usage: %s <reader_num> <writer_num>\n", argv);
exit(1);
}
int reader_num = atoi(argv);
int writer_num = atoi(argv);
// 创建共享内存
int shmid = shmget(IPC_PRIVATE, sizeof(int) * 2, IPC_CREAT | 0666);
read_cnt = (int *)shmat(shmid, 0, 0);
data = read_cnt + 1;
// 初始化共享内存
*read_cnt = 0;
*data = 0;
// 创建信号量
sem_id = semget(IPC_PRIVATE, 2, IPC_CREAT | 0666);
semctl(sem_id, 0, SETVAL, 1);
semctl(sem_id, 1, SETVAL, 1);
// 创建
读者线程
pthread_t tid[reader_num + writer_num];
int index = 0;
for (int i = 0; i < reader_num; i++) {
int *id = malloc(sizeof(int));
*id = ++index;
pthread_create(&tid[i], NULL, reader, id);
}
// 创建
写者线程
for (int i = 0; i < writer_num; i++) {
int *id = malloc(sizeof(int));
*id = ++index;
pthread_create(&tid[reader_num + i], NULL, writer, id);
}
// 等待线程结束
for (int i = 0; i < reader_num + writer_num; i++) {
pthread_join(tid[i], NULL);
}
// 删除信号量
semctl(sem_id, 0, IPC_RMID, 0);
// 删除共享内存
shmdt(read_cnt);
shmctl(shmid, IPC_RMID, 0);
return 0;
}
```
本文探讨了在单读者单写者问题中是否需要加锁的问题。虽然一个简单的例子表明在某些情况下可能不需要加锁，但当涉及到更复杂的场景，如线程间的操作同步时，加锁变得必要，以防止潜在的数据不一致性和程序崩溃。因此，即使是单个读者和单个写者，为了保证数据的正确性和系统的稳定性，仍需要进行互斥保护。
最低0.47元/天 解锁文章
扫一扫
236
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
