基于POSIX标准库的读者-写者问题的简单实现

铁皮暖壶2024-05-14 8:09

文章目录

实验要求

  1. 创建一个控制台进程，此进程包含n个线程。用这n个线程来表示n个读者或写者。
  2. 每个线程按相应测试数据文件的要求进行读写操作。
  3. 用信号量机制 分别实现读者优先和写者优先的读者-写者问题。

分析

由于只有一个共享文件, 而有n个读线程, n个写者线程需要互斥地对该文件进行读写操作

读者写者问题需要保证

  • 读读不互斥、允许多个读者同时进行读操作
  • 读写、写写互斥

保证读写、写写互斥

由于临界资源(共享文件)只有一个, 所以创建一个互斥信号量(资源数量只有1份)mutex_file来对进行对文件地互斥操作

保证多个读者同时进行读操作

由于需要保证多个读者不互斥地对文件进行读操作, 所以设置一个进程内的全局变量(线程共享) reading_count, 表示正在对文件进行读操作的线程的数量.

每当有一个读线程进入临界区后, 对该变量的数值+1.

由于有多个读线程, 所以对该全局变量的访问也需要互斥, 因此增加一个互斥信号量mutex_count

如果读线程判断到reading_count != 0, 则不用对信号量mutex_file做P操作, 可以直接进入临界区. 否则, 即该读线程是第一个读线程, 该读线程首先要对信号量mutex_file做P操作.

读者优先

  • 主函数

    • 打开要互斥访问的文件
    • 初始化信号量
    • 创建N个读者线程, N个写者线程mutex_file信号量代表的

  • 读者线程

    • 不断地请求对文件的操作(对信号量mutex_file进行P操作).
    • 打印读者线程id, 用于后续分析.
    • 如果成功的进入临界区, 读取文件的大小, 并打印到标准输出.

  • 写者线程

    • 不断地请求对文件的操作(对信号量mutex_file进行P操作).
    • 打印写者线程id, 用于后续分析.
    • 如果成功的进入临界区, 则对文件写一行文本, 这里为hello world\n.

实例代码

cpp 复制代码 
#include <iostream>
#include <vector>
#include <unistd.h>
#include <sys/file.h>
#include <pthread.h>
#include <semaphore.h>
// convient to code
#define P(x) sem_wait(x);
#define V(x) sem_post(x);
sem_t mutex_count;
sem_t mutex_file;
sem_t mutex_print; // make the print info correct
int reading_count = 0; // the amount of the reading thread
int fd; // the shared file descriptor
const int N = 5;

// the thread of the writer
char writer_str[] = "hello world\n";
void* writer_thread(void* arg) {
    while (true) {
        // try to operate the file
        P(&mutex_file);

        P(&mutex_print);
        printf("the writer %d is writing\n", arg);
        fflush(stdout);
        V(&mutex_print);
        // write into the file
        write(fd, writer_str, sizeof(writer_str) - 1);
        sleep(1);
        // release the file
        V(&mutex_file);
    }
}
// the thread of the reader
void* reader_thread(void* arg) {
    while (true) {
        // Firstly, we need to check and plus the reading_count
        // so, we try to catch the mutex_count
        P(&mutex_count);
        // if the reader is the first reader
        // if mutex_file = 0, 
        if (reading_count == 0) {
            P(&mutex_file);
        }
        reading_count++;
        V(&mutex_count);

        P(&mutex_print);
        printf("the reader %d is reading  #", arg);
        char buf[1024];
        // move file pointer to left 0, to read all content of file
        lseek(fd, 0, SEEK_SET);
        int len = read(fd, buf, sizeof(buf));
        printf("len = %d\n", len);
        fflush(stdout);
        // printf("str = \n%.*s\n", len, buf);
        // fflush(stdout);
        sleep(1);
        V(&mutex_print);

        // after reading, the reader leave, count--
        P(&mutex_count);
        reading_count--;
        // if the reader is the last reader
        if (reading_count == 0) {
            V(&mutex_file);
        }
        V(&mutex_count);
    }
}
int main(int argc, char const *argv[]) {
    // if use the cmd
    // if (argc < 2) {
    //     printf("usage : %s <n>\n", argv[0]);
    //     exit(1);
    // } 
    // int N = atoi(argv[1]);


    // open a file "data.txt", which can written and read,
    // if not exists, crate it, if already have sth, clear it.
    fd = open("data.txt", O_RDWR | O_CREAT | O_TRUNC);
    if (fd == -1) {
        char msg[] = "error to open the file\n";
        write(2, msg, sizeof(msg) - 1);
        return 1;
    }
    printf("file descriptor = %d\n", fd);

    /**
     * initialize the semaphores
     *  arg1 : the semaphore
     *  arg2: 0 means share in processes
     *  arg3: 1 means initial value of the semaphore, there 1 means mutual-sema
    */
    sem_init(&mutex_count, 0, 1); 
    sem_init(&mutex_file, 0, 1); 
    sem_init(&mutex_print, 0, 1); 


    /**
     * initialize the threads
    */
    std::vector<pthread_t> writer(N), reader(N);
    // create N writer thread, N reader thread
    for (int i = 0; i < N; i++) {
        pthread_create(&writer[i], nullptr, writer_thread, (void*) i + 1);
        pthread_create(&reader[i], nullptr, reader_thread, (void*) (N + i + 1));
    }
    // main thread waiting 2*N threads
    for (int i = 0; i < N; i++) {
        pthread_join(writer[i], nullptr);
        pthread_join(writer[i], nullptr);
    }
    // destory semaphores
    sem_destroy(&mutex_count);
    sem_destroy(&mutex_file);
    sem_destroy(&mutex_print);
    return 0;
}

分析

假设读写线程都有N = 5个, 如果尝试运行一下该程序

由于第一个创建的线程是写线程, 所以writer1会对文件进行写操作

后续当第一个读线程获取到文件的操作权后, 此时后续的读写线程都已经就绪, 因为此时reading_count=1, 所以其余读线程不会执行对信号量mutex_file的P操作, 而直接进入临界区, 但是写线程执行了对信号量mutex_file的P操作, 从而被阻塞, 加如到了该信号量的阻塞队列中. 接着, 其余读线程也顺势进入临界区, 并且由于一个线程内是持续(while(true))对共享文件做P操作的, 所以一个读线程完成读操作后会立即再次对文件发起读请求. 从而使得可能在后续读线程就绪前, 就准备好的写线程一直被阻塞. 从而引起了这些写线程出现饥饿现象.

当然, 如果线程中不加入死循环, 则每个线程只对文件操作一次, 则所有的线程都有机会操作文件.此时写线程只会饥饿, 但不至于饿死. 而加入死循环, 可能会导致线程饿死.

写者优先

在前面读者优先的基础上

统计写者请求的数量

如果有写者正在访问文件, 其它写者在mutex_write_wait排队, 保证写-写互斥

如果有写着在mutex_write_wait上排队, 则让读者在mutex_reader_wait排队, 保证写优先

代码

cpp 复制代码 
#include <iostream>
#include <vector>
#include <unistd.h>
#include <sys/file.h>
#include <pthread.h>
#include <semaphore.h>
// convient to code
#define P(x) sem_wait(x);
#define V(x) sem_post(x);
sem_t mutex_count;
sem_t mutex_file;
sem_t mutex_print; // make the print info correct
int reading_count = 0; // the amount of the reading thread
// the amount of the blocked writer
int writer_count = 0;
sem_t mutex_writer_count;

sem_t mutex_reader_wait;


sem_t mutex_write_wait;
int fd; // the shared file descriptor
const int N = 5;

// the thread of the writer
char writer_str[] = "hello world\n";
void* writer_thread(void* arg) {
    while (true) {
        // try to operate the file

        P(&mutex_writer_count);
        writer_count++;
        if (writer_count == 1) {
            P(&mutex_write_wait);
        }
        V(&mutex_writer_count);

        P(&mutex_file);
        P(&mutex_print);
        printf("the writer %d is writing\n", arg);
        fflush(stdout);
        V(&mutex_print);
        // write into the file
        write(fd, writer_str, sizeof(writer_str) - 1);
        sleep(1);
        // release the file
        V(&mutex_file);

        P(&mutex_writer_count);
        writer_count--;
        if (writer_count == 0) {
            V(&mutex_write_wait);
        }
        V(&mutex_writer_count);
    }
}
// the thread of the reader
void* reader_thread(void* arg) {
    while (true) {
        // Firstly, we need to check and plus the reading_count
        // so, we try to catch the mutex_count

        P(&mutex_reader_wait);
        P(&mutex_write_wait);
        P(&mutex_count);
        // if the reader is the first reader
        // if mutex_file = 0, 
        reading_count++;
        if (reading_count == 1) {
            P(&mutex_file);
        }
        V(&mutex_count);
        V(&mutex_write_wait);
        V(&mutex_reader_wait);

        P(&mutex_print);
        printf("the reader %d is reading  #", arg);
        char buf[1024];
        // move file pointer to left 0, to read all content of file
        lseek(fd, 0, SEEK_SET);
        int len = read(fd, buf, sizeof(buf));
        printf("len = %d\n", len);
        fflush(stdout);
        // printf("str = \n%.*s\n", len, buf);
        // fflush(stdout);
        sleep(1);
        V(&mutex_print);

        // after reading, the reader leave, count--
        P(&mutex_count);
        reading_count--;
        // if the reader is the last reader
        if (reading_count == 0) {
            V(&mutex_file);
        }
        V(&mutex_count);
    }
}
int main(int argc, char const *argv[]) {
    // if use the cmd
    // if (argc < 2) {
    //     printf("usage : %s <n>\n", argv[0]);
    //     exit(1);
    // } 
    // int N = atoi(argv[1]);


    // open a file "data.txt", which can written and read,
    // if not exists, crate it, if already have sth, clear it.
    fd = open("data.txt", O_RDWR | O_CREAT | O_TRUNC);
    if (fd == -1) {
        char msg[] = "error to open the file\n";
        write(2, msg, sizeof(msg) - 1);
        return 1;
    }
    printf("file descriptor = %d\n", fd);

    /**
     * initialize the semaphores
     *  arg1 : the semaphore
     *  arg2: 0 means share in processes
     *  arg3: 1 means initial value of the semaphore, there 1 means mutual-sema
    */
    sem_init(&mutex_count, 0, 1); 
    sem_init(&mutex_file, 0, 1); 
    sem_init(&mutex_print, 0, 1); 
    sem_init(&mutex_writer_count, 0, 1); 
    sem_init(&mutex_reader_wait, 0, 1); 
    sem_init(&mutex_write_wait, 0, 1); 


    /**
     * initialize the threads
    */
    std::vector<pthread_t> writer(N), reader(N);
    // create N writer thread, N reader thread
    for (int i = 0; i < N; i++) {
        pthread_create(&reader[i], nullptr, reader_thread, (void*) i + 1);
        pthread_create(&writer[i], nullptr, writer_thread, (void*) i + 1);
    }
    // main thread waiting 2*N threads
    for (int i = 0; i < N; i++) {
        pthread_join(writer[i], nullptr);
        pthread_join(writer[i], nullptr);
    }
    // destory semaphores
    sem_destroy(&mutex_count);
    sem_destroy(&mutex_file);
    sem_destroy(&mutex_print);
    return 0;
}

运行结果

由于先场景读线程, 所以第一个读线程先读后, 此后一直被写者插队, 导致读者饥饿

读写公平法

前面读者优先的实现问题在于: 当读线程在占用文件时, 其它读线程直接进入临界区, 则不被阻塞, 仅有后续的写线程被阻塞

一种解决办法就是设置一个信号量让两类线程都可以因为请求文件被阻塞, 但是同时保证读-读不被阻塞

我们在原先的读者优先的实现中, 在最外层增加一个互斥信号量mutex_equal

为了保证会因请求文件而阻塞, 所以在对mutex_file进行P操作之前, 对mutex_equal执行P操作

由于要保证多个读者同时读取文件, 则当读者进入临界区后, 对mutex_wprivilege进行V操作

示例代码

cpp 复制代码 
#include <iostream>
#include <vector>
#include <sys/file.h>
#include <unistd.h>
#include <pthread.h>
#include <semaphore.h>
using namespace std;
sem_t mutex_count;
sem_t mutex_print;
sem_t mutex_file;
sem_t mutex_equal;
int reading_count = 0;
int fd;
const int N = 5;
#define P(x) sem_wait(x);
#define V(x) sem_post(x);
/**
 * P -> sem_wait -1
 * V -> sem_post +1
*/
// the thread of the writer
char writer_str[] = "hello world\n";
void* writer_thread(void* arg) {
    while (true) {
        // the first thread try to catch the file 
        P(&mutex_equal);
        P(&mutex_file);

        P(&mutex_print);
        printf("the writer %d is writing\n", arg);
        fflush(stdout);
        V(&mutex_print);

        write(fd, writer_str, sizeof(writer_str) - 1);
        sleep(1);
        V(&mutex_file);
        // the first blocking-thread of mutex_file leave the critical zone
        V(&mutex_equal);
    }
}
// the thread of the reader
void* reader_thread(void* arg) {
    while (true) {
        // check if the first thread of blocked-queue of mutex_file is the writer
        // if there is writer blocking, the write can't go into critcal zone 
        P(&mutex_equal);

        P(&mutex_count);
        // if the reader is the first reader
        if (reading_count == 0) {
            P(&mutex_file);
        }
        reading_count++;
        // read_count++;
        // printf("%d %d\n", write_count, read_count);
        V(&mutex_count);

        P(&mutex_print);
        printf("the reader %d is reading  #", arg);
        char buf[1024];
        // move file pointer to left 0 
        lseek(fd, 0, SEEK_SET);
        int len = read(fd, buf, sizeof(buf));
        printf("len = %d\n", len);
        fflush(stdout);
        // fflush(stdout);
        // printf("str = \n%.*s\n", len, buf);
        sleep(1);
        V(&mutex_print);
        
        V(&mutex_equal);

        // after reading, the reader leave, count--
        P(&mutex_count);
        reading_count--;
        // if the reader is the last reader
        if (reading_count == 0) {
            V(&mutex_file);
        }
        V(&mutex_count);
    }    
}
int main(int argc, char const *argv[]) {
    // if (argc < 2) {
    //     printf("usage : %s <n>\n", argv[0]);
    //     exit(1);
    // } 
    // int N = atoi(argv[1]);
    fd = open("data.txt", O_RDWR | O_CREAT | O_TRUNC);
    /**
     * initialize the semaphores
     *  arg1 : the semaphore
     *  arg2: 0 means share in processes
     *  arg3: 1 means initial value of the semaphore
    */
    sem_init(&mutex_count, 0, 1); 
    sem_init(&mutex_file, 0, 1); 
    sem_init(&mutex_print, 0, 1); 
    sem_init(&mutex_equal, 0, 1); 


    /**
     * initialize the threads
     * 
    */
    printf("file descriptor = %d\n", fd);
    vector<pthread_t> writer(N), reader(N);
    for (int i = 0; i < N; i++) {
        pthread_create(&writer[i], nullptr, writer_thread, (void*) i + 1);
        pthread_create(&reader[i], nullptr, reader_thread, (void*) (N + i + 1));
    }
    // main thread waiting 2*N threads
    for (int i = 0; i < N; i++) {
        pthread_join(writer[i], nullptr);
        pthread_join(writer[i], nullptr);
    }
    // destory semaphores
    sem_destroy(&mutex_count);
    sem_destroy(&mutex_file);
    sem_destroy(&mutex_print);
    sem_destroy(&mutex_equal);
    return 0;
}

分析

修改后的程序的输出结果: 读者和写者较为平均的访问了文件.

对于mutex_equal的阻塞队列的队首.

  • 当mutex_file的阻塞队列为空(这种情况下mutex_equal= 1), 此时mutex_equal的阻塞队列队首的读者线程, 会直接进入临界区.
  • 当mutex_file的阻塞队列有一个写者线程时, 此时mutex_equal的阻塞队列队首的读/写线程都不会进入mutex_file的阻塞队列.

很明显, mutex_file的阻塞队列最多只会有一个线程(只可能是写线程)

相关推荐
Freestyle Coding21 小时前
使用rust自制操作系统内核
c语言·汇编·microsoft·rust·操作系统
打鱼又晒网1 天前
Linux进程间通信——探索共享内存—— 剖析原理， 学习接口应用
linux·运维·服务器·后端·操作系统
skaiuijing3 天前
巧用二级指针
c语言·开发语言·算法·架构·操作系统
打鱼又晒网4 天前
linux进程间通信——学习与应用命名管道， 日志程序的使用与实现
linux·运维·服务器·后端·操作系统
OpenAnolis小助手5 天前
专访AMD：AMD 正式加入龙蜥社区首秀：开源协作与 AI 创新的交汇点
ai·开源·操作系统·龙蜥社区·龙蜥操作系统大会
zhangxueyi5 天前
word文档转换为PPT文档最佳方案
操作系统·文档转换
洛寒瑜5 天前
【读书笔记-《30天自制操作系统》-18】Day19
c语言·开发语言·汇编·笔记·学习·操作系统·文件读取
望获linux6 天前
Linux网络协议栈的实现
linux·服务器·arm开发·网络协议·操作系统·嵌入式操作系统
宇寒风暖7 天前
计算机操作系统之并行性与并发性笔记
学习·操作系统·并行性·并发性
CHENGlady8 天前
操作系统的分化
操作系统
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04Coze扣子平台完整体验和实践（附国内和国际版对比）05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）08CCF-CSP认证考试 202406-3 文本分词 100分题解09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10浏览器插件——ModHeader 的分享和学习