十二、Linux下线程的同步—条件变量读者与写者问题

最新推荐文章于 2023-07-03 16:44:57 发布
最新推荐文章于 2023-07-03 16:44:57 发布
阅读量297 收藏 1
点赞数
分类专栏： Linux多线程 文章标签： Linux 嵌入式 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42169059/article/details/91043804
版权

一、 案例

写者读者案例，线程对共享资源写，写完成后读者继续读，当读取完成后，在通知写者继续写，依次循环。
在这里插入图片描述
存在以下几种情况：

  • 1 个写者，1 个读者
  • 1 个写者，多个读者
  • 多个写者，多个读者
1. 案例1——一个写者，一个读者。
include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
/***********一个线程写，一个线程读*********************/
//定义两个线程的共有资源
typedef struct
{
        int Res;//需要储存的结果值与计算值

        /*写者的条件变量与互斥锁*/
        pthread_cond_t wr_cond;
        pthread_mutex_t wr_mutex;
        int wr_wait;
                
        /*读者的条件变量与互斥锁*/
        pthread_cond_t rd_cond;
        pthread_mutex_t rd_mutex;
        int rd_wait;
        
}Storage;
/*写入数据*/
void set_data(Storage* s,int value)
{
        s->Res=value;
}
/*读取数据*/
int get_data(Storage* s)
{
        return s->Res;
}
/*
*写数据线程，将计算的结果写入到结果值中再通知读线程
*/
void *set_fn(void* arg)
{
        int i=1;
        int sum=0;
        Storage* s=(Storage*)arg;
        //获取计算一个数据值再传送给读数据线程
        for(i=1;i<=100;i++)
        {
                sum=i+100;
                set_data(s,sum);
                printf("0x%lx(count=%d) write data=%d\n",pthread_self(),i,s->Res);
                //对共享的资源条件变量进行上上锁保护，直到读取线程准备完成                      
                pthread_mutex_lock(&s->rd_mutex);
                while(!s->rd_wait)
                {
                        pthread_mutex_unlock(&s->rd_mutex);
                        usleep(100);
                        pthread_mutex_lock(&s->rd_mutex);
                }
                //读取线程准备好之后，清零，下次继续等待。解锁
                s->rd_wait=0;
                pthread_mutex_unlock(&s->rd_mutex);
                //通知读线程
                pthread_cond_broadcast(&s->rd_cond);

                //写线程完成后，再将写线程上锁阻塞，等待读线程想写线程发送命令
                pthread_mutex_lock(&s->wr_mutex);
                s->wr_wait=1;
                pthread_cond_wait(&s->wr_cond,&s->wr_mutex);
                pthread_mutex_unlock(&s->wr_mutex);

        }
        return 0;
}
/*
*读数据线程，将计算的结果写入到结果值中再通知读线程
*/
void *get_fn(void* arg)
{
        Storage* s=(Storage*)arg;
        int i=1;
        for(i=1;i<=100;i++)
        {
                //对条件变量进行上锁。保护等待队列，直到条件变量触发。
                pthread_mutex_lock(&s->rd_mutex);
                s->rd_wait=1;
                pthread_cond_wait(&s->rd_cond,&s->rd_mutex);
                pthread_mutex_unlock(&s->rd_mutex);
                //获取数据
                get_data(s);
                printf("0x%lx(count=%d )get data=%d\r\n",pthread_self(),i,s->Res);
                //对条件变量进行上锁，直到写线程准备好之后，进行广播通知写线程
                pthread_mutex_lock(&s->wr_mutex);
                while(!s->wr_wait)
                {
                        pthread_mutex_unlock(&s->wr_mutex);
                        usleep(100);
                        pthread_mutex_lock(&s->wr_mutex);
                }
                //写数据的条件清零，以便下次等待写线程等待通知
                s->wr_wait=0;
                pthread_mutex_unlock(&s->wr_mutex);
                pthread_cond_broadcast(&s->wr_cond);
        }
        return 0;
}

//主程序，创建读写任务的函数
int main(void)
{
        int err;
        pthread_t set,get;
        Storage s;
        s.wr_wait=0;
        s.rd_wait=0;
        //初始化条件变量与互斥锁
        pthread_cond_init(&s.wr_cond,NULL);
        pthread_cond_init(&s.rd_cond,NULL);
        pthread_mutex_init(&s.wr_mutex,NULL);
        pthread_mutex_init(&s.rd_mutex,NULL);
        //创建两个线程，一个写数据线程一个对数据线程
        if((err=pthread_create(&set,NULL,set_fn,(void*)&s))!=0)
        {
                perror("set_fn creat fail!\r\n");
        }

        if((err=pthread_create(&get,NULL,get_fn,(void*)&s))!=0)
        {
                perror("get_fn creat fail!\r\n");
        }
        //线程等待
        pthread_join(set,NULL);
        pthread_join(get,NULL);
        //线程互斥锁销毁与条件变量销毁
        pthread_mutex_destroy(&s.wr_mutex);
        pthread_mutex_destroy(&s.rd_mutex);
        pthread_cond_destroy(&s.wr_cond);
        pthread_cond_destroy(&s.rd_cond);

        return 0;
}

运行的结果，一直运行值读取的值为200时，结束运行。
在这里插入图片描述

include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<unistd.h>
#include<pthread.h>
/***********一个线程写，一个线程读*********************/
//定义两个线程的共有资源
typedef struct
{
        int Res;//需要储存的结果值与计算值

        /*写者的条件变量与互斥锁*/
        pthread_cond_t wr_cond;
        pthread_mutex_t wr_mutex;
        int wr_count;
                
        /*读者的条件变量与互斥锁*/
        pthread_cond_t rd_cond;
        pthread_mutex_t rd_mutex;
        int rd_count;
        
}Storage;
/*写入数据*/
void set_data(Storage* s,int value)
{
        s->Res=value;
}
/*读取数据*/
int get_data(Storage* s)
{
        return s->Res;
}
/*
*写数据线程，将计算的结果写入到结果值中再通知读线程
*/
void *set_fn(void* arg)
{
        int i=1;
        int sum=0;
        Storage* s=(Storage*)arg;
        //获取计算一个数据值再传送给读数据线程
        for(i=1;i<=100;i++)
        {
                sum=i+100;
                set_data(s,sum);
                printf("0x%lx(count=%d) write data=%d\n",pthread_self(),i,s->Res);
                //对共享的资源条件变量进行上上锁保护，直到读取线程准备完成                      
                pthread_mutex_lock(&s->rd_mutex);
                while(s->rd_count<2)
                {		
                        pthread_mutex_unlock(&s->rd_mutex);
                        usleep(100);
                        pthread_mutex_lock(&s->rd_mutex);
                }
                //读取线程准备好之后，清零，下次继续等待。解锁
                s->rd_count=0;
                pthread_mutex_unlock(&s->rd_mutex);
                //通知读线程
                pthread_cond_broadcast(&s->rd_cond);

                //写线程完成后，再将写线程上锁阻塞，等待读线程想写线程发送命令
                pthread_mutex_lock(&s->wr_mutex);
                s->wr_count=1;
                pthread_cond_wait(&s->wr_cond,&s->wr_mutex);
                pthread_mutex_unlock(&s->wr_mutex);

        }
        return 0;
}
/*
*读数据线程，将计算的结果写入到结果值中再通知读线程
*/
void *get_fn(void* arg)
{
        Storage* s=(Storage*)arg;
        int i=1;
        for(i=1;i<=100;i++)
        {
                //对条件变量进行上锁。保护等待队列，直到条件变量触发。
                pthread_mutex_lock(&s->rd_mutex);
                s->rd_count++;
                pthread_cond_wait(&s->rd_cond,&s->rd_mutex);
                pthread_mutex_unlock(&s->rd_mutex);
                //获取数据
                get_data(s);
                printf("0x%lx(count=%d )get data=%d\r\n",pthread_self(),i,s->Res);
                //对条件变量进行上锁，直到写线程准备好之后，进行广播通知写线程
                pthread_mutex_lock(&s->wr_mutex);
                while(!s->wr_count)
                {
                        pthread_mutex_unlock(&s->wr_mutex);
                        usleep(100);
                        pthread_mutex_lock(&s->wr_mutex);
                }
                //s->wr_count=0;第一次这个值直接赋值0，导致第一次可以正常写读，第二次只能写不能读，应该为
                //当第二次做准备时，第一个读线程已经清零0，使得另外的读线程一直处于循环中while(!s->wr_count)
                //写数据的条件清零，以便下次等待写线程等待通知
                s->wr_count++;
				if(s->wr_count==2)
				{
					s->wr_count=0;
				}
                pthread_mutex_unlock(&s->wr_mutex);
                pthread_cond_broadcast(&s->wr_cond);
        }
        return 0;
}

//主程序，创建读写任务的函数
int main(void)
{
        int err;
        pthread_t set,get1,get2;
        Storage s;
        s.wr_count=0;
        s.rd_count=0;
        //初始化条件变量与互斥锁
        pthread_cond_init(&s.wr_cond,NULL);
        pthread_cond_init(&s.rd_cond,NULL);
        pthread_mutex_init(&s.wr_mutex,NULL);
        pthread_mutex_init(&s.rd_mutex,NULL);
        //创建两个线程，一个写数据线程一个对数据线程
        if((err=pthread_create(&set,NULL,set_fn,(void*)&s))!=0)
        {
                perror("set_fn creat fail!\r\n");
        }

        if((err=pthread_create(&get1,NULL,get_fn,(void*)&s))!=0)
        {
                perror("get1_fn creat fail!\r\n");
        }
		if((err=pthread_create(&get2,NULL,get_fn,(void*)&s))!=0)
        {
                perror("get2_fn creat fail!\r\n");
        }
        //线程等待
        pthread_join(set,NULL);
        pthread_join(get1,NULL);
		pthread_join(get2,NULL);
        //线程互斥锁销毁与条件变量销毁
        pthread_mutex_destroy(&s.wr_mutex);
        pthread_mutex_destroy(&s.rd_mutex);
        pthread_cond_destroy(&s.wr_cond);
        pthread_cond_destroy(&s.rd_cond);

        return 0;
}

在这里插入图片描述

清风吹过心悠哉
关注
专栏目录
Linux系统中线程同步方式中的条件变量操作方法
嵌入式技术开发
11-06 552
条件变量是线程可用的另一种同步机制，条件变量用于自动阻塞线程，知道某个特定事件或某个条件满足为止，通常情况下，条件变量是和互斥锁一起搭配使用的。使用条件变量主要包括两个动作：1、一个线程等待某个条件满足而被阻塞。2、另一个线程中，条件满足时发出“信号”。例子：为了说明这个问题，来看一个没有使用条件变量的例子，生产者---消费者模式，生产者这边负责生产产 品、而消费者负责消费产品，对于消费者来说，没有产品的时候只能等待产品出来，有产品就使用它。
临界区和条件变量实现读写者问题
07-29
关于读写者问题的源码，其中，采用的方式是临界区和条件变量相结合。
互斥量和条件变量解决读者-写者问题
qzk1993的博客
08-11 558
读者-写者问题
多线程同步中的读者写者问题 － linux 平台实现
zxnblake的专栏
05-25 2202
linux 平台下的实现与 windows 很相似，只有一些代码上的小的差别。1： ReaderWriterLock.h， 该文件定义了读写锁的类#ifndef ReaderWriterLock_H#define ReaderWriterLock_H#include #include class ReaderWriterLock{protected: pthread_mutex_t
IPC学习，利用互斥体和条件变量实现读者和写者问题
追寻自己
06-26 692
#include class rwMutex { private:     boost::mutex lockMutex;                         // 同步控制互斥变量,控制对标志量得访问     boost::condition_variable_any condWriter;       // 写者条件变量     boost::condition_va
Linux多线程(读者写者问题与自旋锁)
分享学习的知识，记录我的技术成长道路
08-08 263
读者写者模型类似于生产者消费者模型。同样符合321原则，即三种关系，两个角色，一个交易场所。
Linux线程同步之条件变量
01-09
条件变量是线程可用的另一种同步机制。条件变量给多个线程提供了一个会合的场所。条件本身是由互斥量保护的。线程在改变 条件状态前必须首先锁住互斥量。 　条件变量的初始化 pthread_cond_init 　去除初始化 ...
Linux C中多线程与volatile变量
09-15
综上所述，`volatile`在Linux C多线程编程中主要用于解决共享变量的可见性问题，但在处理多线程同步时，还需要结合其他的同步机制，如互斥锁（`mutex`）、条件变量等，以确保线程安全。理解`volatile`的关键在于它是...
Linux线程管理必备:解析互斥量与条件变量的详解
09-05
条件变量则允许线程等待某些条件满足后才继续执行，增加了线程同步的灵活性。在编写多线程程序时，合理使用互斥量和条件变量可以显著提高程序的稳定性和性能，避免并发问题，如死锁和竞态条件。理解和熟练掌握这些...
进程、线程知识点总结和同步（消费者生产者，读者写者三类问题）、互斥、异步、并发、并行、死锁、活锁的总结...
diaoyanqin5061的博客
03-26 223
进程和程序： 进程：是个动态的概念，指的是一个静态的程序对某个数据集的一次运行活动，而程序是静态的概念，是由代码和数据组成的程序块而已。 进程5大特点：动态性，并发性，独立运行性，异步性，和结构化的特性。 在多道程序环境下，程序不能独立运行，操作系统所有的特征都是基于进程而体现的，只有进程可以在系统中运行，程序运行必须有进程才行。进程是操作系统里资源分配的基本单位，也是独立运行的基...
读者与写者问题
最新发布
oncruise的博客
07-03 1491
本篇文章我们使用C++探讨一下读者与写者问题.
多线程同步之读者写者问题
weixin_33858485的博客
06-23 263
问题定义： 现有一块共享内存，多个读进程和多个写进程。多个读进程可以同时读，但是当有一个写进程正在写时，其他任何读进程或写进程都不能执行。 该问题有3种变种。第一种称为“读者优先”(readers-preference)。在此情况下，只要有进程在读，写进程就得等待。 实现如下： #include <stdio.h> #include <stdlib.h&gt...
操作系统清华大学版笔记（十） 信号量、管程、条件互斥、经典同步问题（读者写者、哲学家问题）
凝视深渊
12-25 3331
前篇在此： 操作系统清华向勇陈渝版笔记（九） 同步协同多道程序设计和并发问题，同步互斥，死锁，临界区 操作系统（八）CPU调度 短剩余时间 吞吐量 轮循 实时调度 多处理器调度 （清华 向勇 陈渝版）index 10-1 信号量 10-2 如何使用信号量 10-3 信号量实现细节 10-4 管程 条件变量 10-5 经典同步问题10-1 信号量 Semaphore一个整型int（sem
Linux系统编程读写锁和条件变量使用
a_hang_szz的博客
06-05 387
文章目录1.读写锁概念2.条件变量的概念和使用 1.读写锁概念 1.读写锁的适用场景? 互斥锁- - -读写串行 读写锁- - -: 读: 并行 写:串行 程序中的读操作大于写操作的时候 2.代码展示 创建三个写线程,创建五个读线程 为了防止数据混乱(CPU调度问题) 需要给共享资源上锁,保证数据的整齐 使用读写锁 #include <stdio.h> #include <uni...
Linux练习_线程练习_读者写者问题
weixin_44342705的博客
05-11 264
经典线程同步案例 读者写者问题 案例介绍 进程： 写者进程——负责写入数据 读者进程——读取数据 分析： 当写者进程还没写完数据之前，读者只能等待阻塞，当写者写完以后，通知读者可以进行读取数据。 当读者读完数据后，反过来去通知写者继续写入数据 框图 代码： /* * 读者写者问题 * 轮流写入读取100次，写一个读一个 * * */ #include <pthread.h> #include <string.h> #include <s
Linux--Condition Variable（条件变量）实现生产者-消费者模型 、读写锁
weixin_34318326的博客
04-26 191
一、条件变量在线程同步过程中还有如下的情况：线程A需要等某个条件成立之后才能继续往下执行，如果条件不成立，线程A就阻塞，而线程B在执行过程中使这个条件成立了，就唤醒线程A继续执行。在Pthread库中用条件变量阻塞等待一个条件，或者唤醒等待这个条件的线程。条件变量用pthread_cond_t类型的变量来表示。用pthread_cond_init 初始化条件变...
两个条件变量实现读写锁，写优先，避免写者饥饿
znHD的博客
08-08 2439
核心思想：用两个int记录写者数与读者数，用两个条件变量分别作为读者、写者的等待队列。 class wfirtst_rwlock { public: wfirtst_rwlock() :rcount(0), wcount(0),writeflag(true) {} void readlock() { unique_lock&lt;mutex&gt; ul(mtx); cond...
经典同步问题（三）---读者写者问题
热门推荐
sunny_ss12的专栏
08-12 1万+
读者写者问题的信号量和条件变量算法
Linux多线程同步：互斥锁、条件变量与信号量解析
"这篇文档介绍了Linux系统中用于多线程同步的三种机制——互斥锁、条件变量和信号量，重点讲述了互斥锁的概念、使用方法以及注意事项，以确保对共享资源的正确访问和管理。" 在多线程编程中，尤其是在Linux环境下，...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值