Linux并发与同步专题 (5) 读写锁

最新推荐文章于 2023-09-11 11:13:00 发布
最新推荐文章于 2023-09-11 11:13:00 发布
阅读量225 收藏 1
点赞数
分类专栏： Linux并发与同步
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ds1130071727/article/details/93619904
版权

    在多线程程序中，有一种读写者的问题，即对某些资源的访问，存在两种可能的情况，一种是访问必须排他的，称为写操作;另外一种访问是可共享的，称为读操作。

    处理读写着问题的两种常见策略是：强读者同步和强写者同步在强读者同步过程中，总是给读者优先权，只要写着当前没有进行写操作，读者就可以获得访问权。在强写者同步过程中，通常将优先权先交给写者，而将读者延迟到所有等待的或者活动的写者都完成为止简单的说：

    （1）可以同时存在多个读操作

    （2）写必须互斥（只允许一个写操作，不能读写操作同时进行）

    （3）写操作优先于读操作，（一旦有写操作，后续的读操作必须等待，唤醒时有限考虑写操作）

    下面是两种读写锁的使用示例。
    一：POSIX下的rw_lock

code:

#include < pthread 。h >
#include < cstdlib >
#include < ctime >
#include < iostream >
using namespace std ;

static int count = 0 ;
课堂考试
{
私人的 ： 
    pthread_rwlock_t rwlock ;
    
    static void * shared_task_handler （ void * arg ）
    {
        Test * testptr = static_cast < Test * > （ arg ）;
        pthread_rwlock_rdlock （＆ testptr - > rwlock ）;
        / /     做共享在这里的任务
        COUT < < “读---计数=” < <计数< < ENDL ;
        if （ pthread_rwlock_unlock （＆ testptr - > rwlock ） ）
        {
            COUT < < “读解锁错误” < < ENDL ;
        }
        返回NULL ;
    }
    
    static void * exclusive_task_handler （ void * arg ）
    {
        Test * testptr = static_cast < Test * > （ arg ）;
        pthread_rwlock_wrlock （＆ testptr - > rwlock ）;
        / / 做专属任务在这里
        + +计数;
        COUT < < “写-计数=” < <计数< < ENDL ;
        if （ pthread_rwlock_unlock （＆ testptr - > rwlock ） ）
        {
            COUT < < “写解锁错误” < < ENDL ;
        }
        返回NULL ;
    }
    
公众 ：
    typedef void * （* ThreadFunc ） （ void * ）;
    void start （）
    {
        srand （time （NULL ））;
        
        if （ pthread_rwlock_init （＆ rwlock ，NULL ） ）
        {
            COUT < < “rwlock中初始化错误” < < ENDL ;
        }

        const int THREADS_NO = rand （）％ 100 ;
        pthread_t * threads = new pthread_t [ THREADS_NO ] ;

        for （int i = 0 ; i < THREADS_NO ; + + i ）
        {
            ThreadFunc tmpfunc = rand （） ％ 2 ？shared_task_handler ： exclusive_task_handler ;
            if （ pthread_create （ threads + i ，NULL ， tmpfunc ， this ））
            {
                CERR < < “在pthread_create失败” < < ENDL ;
                退出（ 1 ）;
            }
        }
        rwlock中
        for （int i = 0 ; i < THREADS_NO ; i + + ）
        {
            pthread_join （ threads [ i ] ，NULL ）;
        }
        删除[ ]线程;
    }
} ;

int main （）
{
    测试tmptest ;
    tmptest 。start （）;
}

output:

book @ book -桌面：〜/分享$ 。/ posix_read_write_lock
写- - count = 1
写- -计数= 2
写- -计数= 3
读- - -计数= 3
读- - -计数= 3
读- - -计数= 3
读- - -计数= 3
写- -计数= 4
读- - - count = 4
写- -计数= 5
写- -计数= 6
读- - - count = 6
读- - - count = 6
读- - - count = 6
读- - - count = 6
写- -计数= 7
写- - count = 8
读- - - count = 8
读- - - count = 8
写- - count = 9
写- -计数= 10
读- - - count = 10
读- - - count = 10
读- - - count = 10
读- - - count = 10
读- - - count = 10
读- - - count = 10
读- - - count = 10
写- -计数= 11
写- -计数= 12
写- -计数= 13
写- -计数= 14
写- -计数= 15
读- - -计数= 15

 

二：利用pthread_cond_ *＆pthread_mutex_ *实现rw_lock

code:

#include < pthread 。h >
#include < cstdlib >
#include < ctime >
#include < iostream >
using namespace std ;

RWLock 类
{
私人的 ：
    pthread_mutex_t cnt_mutex ;
    pthread_cond_t rw_cond ;
    int rd_cnt ， wr_cnt ;

    RWLock （const RWLock ＆）;
    RWLock ＆ operator = （const RWLock ＆）;

公众 ：
    RWLock （）： rd_cnt （ 0 ）， wr_cnt （ 0 ）
    {
        pthread_mutex_init （＆ cnt_mutex ， NULL ）;
        pthread_cond_init （＆ rw_cond ， NULL ）;
    }

    void get_shared_lock （）
    {
        pthread_mutex_lock （＆ cnt_mutex ）;
        而 （ wr_cnt > 0 ）
        {
            pthread_cond_wait （＆ rw_cond ，＆ cnt_mutex ）;
        }
        rd_cnt + + ;
        pthread_mutex_unlock （＆ cnt_mutex ）;
    }

    void release_shared_lock （）
    {
        pthread_mutex_lock （＆ cnt_mutex ）;
        rd_cnt - - ;
        if （ 0 = = rd_cnt ）
        {
            pthread_cond_signal （＆ rw_cond ）;
        }
        pthread_mutex_unlock （＆ cnt_mutex ）;
    }

    void get_exclusive_lock （）
    {
        pthread_mutex_lock （＆ cnt_mutex ）;
        while （ rd_cnt + wr_cnt > 0 ）
        {
            pthread_cond_wait （＆ rw_cond ，＆ cnt_mutex ）;
        }
        wr_cnt + + ;
        pthread_mutex_unlock （＆ cnt_mutex ）;
    }

    void release_exclusive_lock （）
    {
        pthread_mutex_lock （＆ cnt_mutex ）;
        wr_cnt - - ;
        pthread_cond_broadcast （＆ rw_cond ）;
        pthread_mutex_unlock （＆ cnt_mutex ）;
    }

    ~ RWLock （）
    {
        pthread_mutex_destroy （＆ cnt_mutex ）;
        pthread_cond_destroy （＆ rw_cond ）;
    }
} ;

static int count = 0 ;
课堂考试
{
私人的 ： 
    RWLock锁;
    
    static void * shared_task_handler （ void * arg ）
    {
        Test * testptr = static_cast < Test * > （ arg ）;
        testptr - >锁定。get_shared_lock （）;
        / /     做共享在这里的任务
        COUT < < “读---计数=” < <计数< < ENDL ;
        testptr - >锁定。release_shared_lock （）;
    }
    
    static void * exclusive_task_handler （ void * arg ）
    {
        Test * testptr = static_cast < Test * > （ arg ）;
        testptr - >锁定。get_exclusive_lock （）;
        / / 做专属任务在这里
        + +计数;
        COUT < < “写-计数=” < <计数< < ENDL ;
        testptr - >锁定。release_exclusive_lock （）;
    }
    
公众 ：
    typedef void * （* ThreadFunc ） （ void * ）;
    void start （）
    {
        srand （time （NULL ））;

        const int THREADS_NO = rand （）％ 100 ;
        pthread_t * threads = new pthread_t [ THREADS_NO ] ;

        for （int i = 0 ; i < THREADS_NO ; + + i ）
        {
            ThreadFunc tmpfunc = rand （） ％ 2 ？shared_task_handler ： exclusive_task_handler ;
            if （ pthread_create （ threads + i ，NULL ， tmpfunc ， this ））
            {
                CERR < < “在pthread_create失败” < < ENDL ;
                退出（ 1 ）;
            }
        }

        for （int i = 0 ; i < THREADS_NO ; i + + ）
        {
            pthread_join （ threads [ i ] ，NULL ）;
        }

        删除[ ]线程;
    }
} ;

int main （）
{
    测试tmptest ;
    tmptest 。start （）;
}

output:

book @ book -桌面：〜/分享$ 。/ read_write_lock
读- - - count = 0
读- - - count = 0
读- - - count = 0
写- - count = 1
读- - - count = 1
读- - - count = 1
读- - - count = 1
读- - - count = 1
写- -计数= 2
写- -计数= 3
读- - -计数= 3
读- - -计数= 3
读- - -计数= 3
读- - -计数= 3
读- - -计数= 3
读- - -计数= 3
读- - -计数= 3
读- - -计数= 3
读- - -计数= 3
读- - -计数= 3
读- - -计数= 3
读- - -计数= 3
读- - -计数= 3
写- -计数= 4
写- -计数= 5
写- -计数= 6
写- -计数= 7
写- - count = 8
写- - count = 9
写- -计数= 10
写- -计数= 11
读- - -计数= 11
写- -计数= 12
写- -计数= 13
读- - - count = 13
读- - - count = 13
写- -计数= 14
写- -计数= 15
写- -计数= 16
写- -计数= 17
写- -计数= 18
写- -计数= 19
读- - - count = 19
写- -计数= 20
读- - -计数= 20
写- -计数= 21
读- - -计数= 21
写- -计数= 22
读- - -计数= 22
读- - -计数= 22
写- -计数= 23
读- - -计数= 23
读- - -计数= 23
读- - -计数= 23
写- -计数= 24
读- - -计数= 24
写- -计数= 25
写- -计数= 26
写- -计数= 27
写- -计数= 28
读- - -计数= 28
读- - -计数= 28
写- -计数= 29
写- -计数= 30
读- - -计数= 30
读- - -计数= 30
读- - -计数= 30
写- -计数= 31
读- - -计数= 31
读- - -计数= 31
写- -计数= 32
读- - -计数= 32
写- -计数= 33
读- - -计数= 33
读- - -计数= 33
读- - -计数= 33
读- - -计数= 33
读- - -计数= 33
写- -计数= 34
写- -计数= 35

 

ch3rry
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux操作系统之读写锁
xx18030637774的博客
09-05 3630
（1）读写锁：只有一把锁，但是有两种状态（读，写）              1）读写锁的三种状态：读锁，写锁，不加锁              2）读写锁特性（12字）：写锁优先级高，写独占，读共享                     1&gt;写模式加锁时，解锁前，所有对该线程加锁的线程都会被阻塞。                     2&gt;读模式加锁时，如果线程是读加锁则...
Linux线程同步之读写锁（rwlock）
jishublog
06-26 440
读写锁和互斥量（互斥锁）很类似，是另一种线程同步机制，但不属于POSIX标准，可以用来同步同一进程中的各个线程。当然如果一个读写锁存放在多个进程共享的某个内存区中，那么还可以用来进行进程间的同步， 和互斥量不同的是：互斥量会把试图进入已保护的临界区的线程都阻塞；然而读写锁会视当前进入临界区的线程和请求进入临界区的线程的属性来判断是否允许线程进入。 相对互斥量只有加锁和不加锁两种状态，读写锁...
linux线程同步-读写锁(reader-writer lock)
背着行囊去远方的博客
08-30 638
互斥锁是要么加锁要么不加锁，而且同一时刻只允许一个线程对其加锁。 读写锁有更高的并行性： 1、读写锁有三种状态：读模式下加速（共享）、写模式下加锁（独占）以及不加锁。 2、一次只有一个线程可以占有写模式下的读写锁；但是多个线程可以同时占有读模式下的读写锁。 3、读写锁在写加锁状态时，其他试图以写状态加锁的线程都会被阻塞。读写锁在读加锁状态时，如果有线程希望以写模式加锁时，必须阻塞，直...
七、读写锁
博观而约取
12-19 430
01. 读写锁概述 当有一个线程已经持有互斥锁时，互斥锁将所有试图进入临界区的线程都阻塞住。但是考虑一种情形，当前持有互斥锁的线程只是要读访问共享资源，而同时有其它几个线程也想读取这个共享资源，但是由于互斥锁的排它性，所有其它线程都无法获取锁，也就无法读访问共享资源了，但是实际上多个线程同时读访问共享资源并不会导致问题。 在对数据的读写操作中，更多的是读操作，写操作较少，例如对数据库数据的读写应...
linux 文件读写 锁操作
03-18 540
linux 文件读写 锁操作   2011-04-15 16:44:46|  分类： linux |  标签：ubuntu  linux  锁  文件读写   |举报 |字号大中小 订阅 linux文件操作学习（linux c 编程实战）。 锁的规则： 多进程：锁的不兼容性规则：       多进程在给一个给定的字节上可以有一把共享的读锁，但是在一个
linux 可执行文件与写操作的同步问题(文件读写操作产生的锁机制)
09-15
文件锁机制是为了确保在并发环境下对同一文件进行读写操作时不会出现数据不一致或者破坏文件结构的情况。本文将深入探讨Linux下针对可执行文件的写操作同步以及其背后的锁机制。 首先，我们要理解的是Linux中的`...
windows和linux读写锁C++实现
01-17
在多线程编程中，读写锁是一种非常重要的同步机制，它允许多个读线程同时访问共享资源，但只允许一个写线程独占资源，从而提高了并发性能。本话题将详细探讨在Windows和Linux环境下，如何使用C++来实现读写锁。 ...
linux下实现高性能读写锁（read/write lock）
07-07
在Linux系统中，读写锁（Read/Write Locks，简称rwlocks）是一种多线程同步机制，它允许多个线程同时进行读操作，但只允许一个线程执行写操作。这种锁的设计目的是提高并发性能，特别是当读操作远多于写操作时。在...
嵌入式Linux中的进程同步无竞争态读写
08-04
通过这种方式，即使在没有锁的情况下，只要正确地同步读写操作，也能避免竞态条件的发生。 综上所述，嵌入式Linux中的进程同步无竞争态读写主要依赖于信号量机制来实现生产者-消费者问题的解决方案，确保在有限缓冲...
windows/linux读写锁简单改进版本
09-23
读写锁（Read-Write Lock）是多线程编程中的一种同步机制，它允许多个线程同时读取共享资源，但只允许一个线程写入。这种锁在高并发读取场景下能显著提高系统性能，因为它减少了锁的争用。在Windows和Linux操作系统...
linux文件读写锁实例C代码
04-08
linux文件读写锁一个例子，已经通过测试，使用非常方便
linux读写锁
m0_57678852的博客
11-20 2213
3） 读写不能同时进行，写的优先级高：例如，线程A加读锁成功，又来了B线程加写锁阻塞，又来了C线程加读锁阻塞。4）线程 A 加读锁成功，然后线程 B 请求写锁，然后线程 C 请求读锁 ：B 写阻塞，C 读阻塞；5）线程 A 加读写成功，然后线程 B 请求读锁，然后线程 C 请求写锁 ：B 读阻塞，C 写阻塞；2）写独占-串行处理：例如，线程 A 加写锁成功，有来个 3 个线程，作读操作，3 个线程阻塞。1）读共享-并行处理：例如，线程 A 加读锁成功，有来个 3 个线程，作读操作，也可加锁成功。
linux-读写锁(rwlock)
最新发布
jiu_yue_ya的博客
09-11 481
动态初始化是在堆中申请空间，需要释放，而静态初始化是在静态存储区中创建，不。在 linux 中，通过 pthread_rwlock_t 结构来表示一个读写锁。1.如果有其它线程读数据，则允许其它线程执行读操作，但不允许写操作；3 如果某线程申请了读锁，其它线程可以再申请读锁，但不能申请写锁；4.如果某线程申请了写锁，其它线程不能申请读锁，也不能申请写锁。读写锁与互斥量类似，不过读写锁允许更改的并行性，释放读写锁(pthread_rwlock_destroy)读写锁的属性，为 NULL 表示默认属性。
Linux线程：读写锁的使用
坚持学习
05-02 392
Linux线程：读写锁的使用
Linux 网络协议栈之内核锁（七）—— 读写自旋锁
知秋一叶
02-05 1227
读写自旋锁（rwlock）是一种比自旋锁粒度更小的自旋锁机制，它保留了“自旋”的概念。 但是在写操作方面，只能最多有一个写进程，在读方面，同时可拥有多个执行单元，当然读和写也不能同时进行。 一句话：防写不防读 读写自旋锁的实现原理，它其实是自旋锁的升级版。同样，我们先看看它能实现的功能：针对写：最多只有一个写进程；针对读：可以同时有多个读写单元。但读和写不能同时进行。它于in
Linux读写锁的使用
qq_40888486的博客
08-30 273
1. 读写锁介绍 读写锁的类型可以分为读锁和写锁，以读方式给数据加锁—读锁。以写方式给数据加锁—写锁。但是读写锁是一把锁，每个线程只可以带一个锁类型。 特性：（举例说明） 1. 线程A加读锁成功，又来了三个线程，做读操作，三个线程再次加锁成功。 ———结论：读时共享，并行处理 2.线程A加写锁成功，又来了三个线程，做读操作，三个线程再次加锁失败。 ———结论：写时独占 3.线程A加锁成功，又来了线程B加写锁阻塞，又来了C线程加读锁阻塞。 ———结论：（1）读写不能同时进行，（2）写的优先级高
linux 文件读写锁,读写锁(read-write lock)机制-----多线程同步问题的解决
weixin_42300418的博客
04-28 781
读写锁(read-write lock)一 综述在一些程序中存在读者写者问题，也就是说，对某些资源的访问会 存在两种可能的情况，一种是访问必须是排它行的，就是独占的意思，这称作写操作；另一种情况就是访问方式可以是共享的，就是说可以有多个线程同时去访问某个资源，这种就称作读操作。这个问题模型是从对文件的读写操作中引申出来的。读写锁比起mutex具有更高的适用性，具有更高的并行性，可以有多个线程同时...
pthread_spin_lock 自旋锁
热门推荐
JoJo-追求卓越~
05-22 1万+
锁机制(lock) 是多线程编程中最常用的同步机制,用来对多线程间共享的临界区(Critical Section) 进行保护。 Pthreads提供了多种锁机制,常见的有： 1) Mutex（互斥量）：pthread_mutex_*** 2) Spin lock（自旋锁）：pthread_spin_*** 3) Condition Variable（条件变量）：pthread_con_**
关于linux的读写锁
lotluck的专栏
04-07 3480
这次当我给面试官提及到读写锁的时候，详细问了我的读写锁，我知道怎么回事，用法，但是具体没实践过，听过的还是不要给面试官说了，不然又给自己挖坑。    下面这个程序就是读写锁的程序，分别有两个读者，两个写着，当写着输入end的时候并且读者读到程序运行结束，里面的读写锁是动态初始化，最后用pthread_join()，主要主线程等待子线程运行完她才可以结束。对于现在锁，我才感觉到都是有套路的，都被玩
Linux内核锁详解：并发问题与同步策略
深入研究内核锁对于任何与Linux内核编程相关的专业人士来说都是必不可少的，它涉及到底层并发控制、系统资源管理和性能优化等多个方面。通过掌握这些知识，开发者能够构建出健壮且高效的并发代码，确保系统的稳定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值