C语言实现操作系统经典的进程同步问题（3）

news2024/10/3 7:16:48

读者-写者问题

1、利用记录型信号量解决读者-写者问题

通过POSIX信号量实现。

#include <stdio.h>  
#include <stdlib.h>  
#include <pthread.h>  
#include <semaphore.h>  
#include <unistd.h>  
  
#define NUM_READERS 5  
#define NUM_WRITERS 3  
#define READ_TIME 2  
#define WRITE_TIME 1  
  
sem_t rw_mutex;      // 保护共享资源的互斥锁  
sem_t mutex;         // 保护读者计数的互斥锁  
int read_count = 0;  // 当前正在读取的读者数量  
  
void *reader(void *arg) {  
    int reader_id = *((int *)arg);  
    while (1) {  
        // 请求读取锁  
        sem_wait(&mutex);  
        read_count++;  
        if (read_count == 1) {  
            sem_wait(&rw_mutex);  // 第一个读者获得写锁（独占）  
        }  
        sem_post(&mutex);  
  
        // 读取操作  
        printf("Reader %d is reading.\n", reader_id);  
        sleep(READ_TIME);  
  
        // 释放读取锁  
        sem_wait(&mutex);  
        read_count--;  
        if (read_count == 0) {  
            sem_post(&rw_mutex);  // 最后一个读者释放写锁  
        }  
        sem_post(&mutex);  
  
        sleep(1);  // 读者休息一会儿再尝试读取  
    }  
    return NULL;  
}  
  
void *writer(void *arg) {  
    int writer_id = *((int *)arg);  
    while (1) {  
        // 请求写入锁  
        sem_wait(&rw_mutex);  
  
        // 写入操作  
        printf("Writer %d is writing.\n", writer_id);  
        sleep(WRITE_TIME);  
  
        // 释放写入锁  
        sem_post(&rw_mutex);  
  
        sleep(1);  // 写者休息一会儿再尝试写入  
    }  
    return NULL;  
}  
  
int main() {  
    pthread_t readers[NUM_READERS], writers[NUM_WRITERS];  
    int reader_ids[NUM_READERS], writer_ids[NUM_WRITERS];  
  
    // 初始化信号量  
    sem_init(&rw_mutex, 0, 1);  
    sem_init(&mutex, 0, 1);  
  
    // 创建读者线程  
    for (int i = 0; i < NUM_READERS; i++) {  
        reader_ids[i] = i;  
        pthread_create(&readers[i], NULL, reader, &reader_ids[i]);  
    }  
  
    // 创建写者线程  
    for (int i = 0; i < NUM_WRITERS; i++) {  
        writer_ids[i] = i;  
        pthread_create(&writers[i], NULL, writer, &writer_ids[i]);  
    }  
  
    // 等待线程结束（实际上这些线程是无限循环的，这里只是为了示例）  
    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(&rw_mutex);  
    sem_destroy(&mutex);  
  
    return 0;  
}

信号量初始化：

rw_mutex：用于保护共享资源的互斥锁，初始值为1，表示资源可用。
mutex：用于保护读者计数read_count的互斥锁，初始值为1，表示可访问。

读者线程：

使用sem_wait(&mutex)请求访问读者计数互斥锁。
增加read_count，如果这是第一个读者，则请求rw_mutex锁，独占资源。
释放mutex锁。
执行读取操作。
再次请求mutex锁，减少read_count，如果这是最后一个读者，则释放rw_mutex锁。
释放mutex锁。

写者线程：

直接请求rw_mutex锁，独占资源。
执行写入操作。
释放rw_mutex锁。

主函数：

创建读者和写者线程。
等待线程结束（这里示例代码中的线程是无限循环的，实际使用时可能需要加入退出条件）。
销毁信号量

2、利用信号量集机制解决读者-写者问题

使用了信号量（semaphores）来管理对共享资源的访问。

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

#define NUM_READERS 5
#define NUM_WRITERS 3
#define READ_TIME 2
#define WRITE_TIME 1

sem_t rw_mutex;      // 保护共享资源的互斥锁
sem_t mutex;         // 保护读者计数的互斥锁
int read_count = 0;  // 当前正在读取的读者数量

void *reader(void *arg) {
    int reader_id = *((int *)arg);
    while (1) {
        sem_wait(&mutex);
        read_count++;
        if (read_count == 1) {
            sem_wait(&rw_mutex);
        }
        sem_post(&mutex);

        printf("Reader %d is reading.\n", reader_id);
        sleep(READ_TIME);

        sem_wait(&mutex);
        read_count--;
        if (read_count == 0) {
            sem_post(&rw_mutex);
        }
        sem_post(&mutex);

        sleep(1);
    }
    return NULL;
}

void *writer(void *arg) {
    int writer_id = *((int *)arg);
    while (1) {
        sem_wait(&rw_mutex);

        printf("Writer %d is writing.\n", writer_id);
        sleep(WRITE_TIME);

        sem_post(&rw_mutex);

        sleep(1);
    }
    return NULL;
}

int main() {
    pthread_t readers[NUM_READERS], writers[NUM_WRITERS];
    int reader_ids[NUM_READERS], writer_ids[NUM_WRITERS];

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

    for (int i = 0; i < NUM_READERS; i++) {
        reader_ids[i] = i;
        pthread_create(&readers[i], NULL, reader, &reader_ids[i]);
    }

    for (int i = 0; i < NUM_WRITERS; i++) {
        writer_ids[i] = i;
        pthread_create(&writers[i], NULL, writer, &writer_ids[i]);
    }

    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(&rw_mutex);
    sem_destroy(&mutex);

    return 0;
}