经典的读者写者问题

最新推荐文章于 2022-01-15 15:56:55 发布
最新推荐文章于 2022-01-15 15:56:55 发布
阅读量740 收藏
点赞数
分类专栏： 操纵系统 文章标签： 读写锁 同步与互斥
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xtank_nie/article/details/52073804
版权 
<span style="font-size:14px;">/*
 * read_write_lock.h
 *
 *  Created on: July 29, 2016  09:55:16
 *      Author: xtank.nie@gmail.com
 */

#ifndef __READ_WRITE_LOCK_H__
#define __READ_WRITE_LOCK_H__
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */

#include <stdint.h>
#include <pthread.h>
#include <emmintrin.h>


/******************************************************************************/
enum read_write_priority_mode_e
{
    RD_PRI_MODE = 0,
    WR_PRI_MODE,
};

/******************************************************************************/
struct read_write_lock_s;
typedef void (*read_write_lock_r_lock_func)(struct read_write_lock_s *);
typedef void (*read_write_lock_r_unlock_func)(struct read_write_lock_s *);
typedef void (*read_write_lock_w_lock_func)(struct read_write_lock_s *);
typedef void (*read_write_lock_w_unlock_func)(struct read_write_lock_s *);

/******************************************************************************/
typedef struct read_write_lock_s
{
    uint32_t priority_mode;

    uint32_t reader_cnt;
    pthread_mutex_t reader_cnt_mutex;

    uint32_t writer_cnt;
    pthread_mutex_t writer_cnt_mutex;

    pthread_mutex_t reader_writer_writer_mutex;     /**< 读写互斥, 写写互斥 */

    pthread_mutex_t first_reader_mutex;
    pthread_mutex_t wait_reader_mutex;

    read_write_lock_r_lock_func rwl_read_lock;
    read_write_lock_r_unlock_func rwl_read_unlock;
    read_write_lock_w_lock_func rwl_write_lock;
    read_write_lock_w_unlock_func rwl_write_unlock;
}read_write_lock_t;

/******************************************************************************/
/*
 * 读者优先: 根据读写问题的基本特性: 读读同步, 读写互斥, 写写互斥,
 * 必须待所有读者完成读取后, 写者才可进行写入, 极端情况存在写者饥饿现象
 */
/******************************************************************************/
static inline void
read_write_lock_r_lock_read_first(read_write_lock_t *rwl)
{
    pthread_mutex_lock(&rwl->reader_cnt_mutex);
    if (rwl->reader_cnt++ == 0)
        pthread_mutex_lock(&rwl->reader_writer_writer_mutex);
    pthread_mutex_unlock(&rwl->reader_cnt_mutex);
}

/******************************************************************************/
static inline void
read_write_lock_r_unlock_read_first(read_write_lock_t *rwl)
{
    pthread_mutex_lock(&rwl->reader_cnt_mutex);
    if (--rwl->reader_cnt == 0)
        pthread_mutex_unlock(&rwl->reader_writer_writer_mutex);
    pthread_mutex_unlock(&rwl->reader_cnt_mutex);
}

/******************************************************************************/
static inline void
read_write_lock_w_lock_read_first(read_write_lock_t *rwl)
{
    pthread_mutex_lock(&rwl->reader_writer_writer_mutex);
}

/******************************************************************************/
static inline void
read_write_lock_w_unlock_read_first(read_write_lock_t *rwl)
{
    pthread_mutex_unlock(&rwl->reader_writer_writer_mutex);
}

/*
 * 写者优先: 根据读写问题的基本特性: 读读同步, 读写互斥, 写写互斥,
 * 且避免"读者问题带来可能的饥饿情况, 考虑这样的情况: 存在多个读者工作的同时, 有
 * 新的写者进入等待, 则让当前进行的读者读完后让写者插队进入写操作, 第二个读者暂
 * 时进入等待状态, 待写者完成时方可进行读取;
 */
/******************************************************************************/
static inline void
read_write_lock_r_lock_write_first(read_write_lock_t *rwl)
{
    pthread_mutex_lock(&rwl->wait_reader_mutex);
    pthread_mutex_lock(&rwl->first_reader_mutex);

    pthread_mutex_lock(&rwl->reader_cnt_mutex);
    if (++rwl->reader_cnt == 1)
        pthread_mutex_lock(&rwl->reader_writer_writer_mutex);
    pthread_mutex_unlock(&rwl->reader_cnt_mutex);

    pthread_mutex_unlock(&rwl->first_reader_mutex);
    pthread_mutex_unlock(&rwl->wait_reader_mutex);
}
static inline void
read_write_lock_r_unlock_write_first(read_write_lock_t *rwl)
{
    pthread_mutex_lock(&rwl->reader_cnt_mutex);
    if (--rwl->reader_cnt == 0)
        pthread_mutex_unlock(&rwl->reader_writer_writer_mutex);
    pthread_mutex_unlock(&rwl->reader_cnt_mutex);
}

static inline void
read_write_lock_w_lock_write_first(read_write_lock_t *rwl)
{
    pthread_mutex_lock(&rwl->writer_cnt_mutex);
    if (++rwl->writer_cnt == 1)
        pthread_mutex_lock(&rwl->first_reader_mutex);
    pthread_mutex_unlock(&rwl->writer_cnt_mutex);
    pthread_mutex_lock(&rwl->reader_writer_writer_mutex);
}
static inline void
read_write_lock_w_unlock_write_first(read_write_lock_t *rwl)
{
    pthread_mutex_unlock(&rwl->reader_writer_writer_mutex);
    pthread_mutex_lock(&rwl->writer_cnt_mutex);
    if (--rwl->writer_cnt == 0)
        pthread_mutex_unlock(&rwl->first_reader_mutex);
    pthread_mutex_unlock(&rwl->writer_cnt_mutex);
}

/******************************************************************************/
/******************************************************************************/
static inline void
read_write_lock_init(read_write_lock_t *rwl,
    enum read_write_priority_mode_e mode)
{
    int ret = 0;
    rwl->priority_mode = mode;

    switch (mode)
    {
        case RD_PRI_MODE:
        {
            pthread_mutex_init(&rwl->reader_cnt_mutex, NULL);
            rwl->reader_cnt = 0;
            pthread_mutex_init(&rwl->reader_writer_writer_mutex, NULL);
            rwl->rwl_read_lock = read_write_lock_r_lock_read_first;
            rwl->rwl_read_unlock = read_write_lock_r_unlock_read_first;
            rwl->rwl_write_lock = read_write_lock_w_lock_read_first;
            rwl->rwl_write_unlock = read_write_lock_w_unlock_read_first;
        }
        break;
        case WR_PRI_MODE:
        {
            pthread_mutex_init(&rwl->writer_cnt_mutex, NULL);
            rwl->writer_cnt = 0;
            pthread_mutex_init(&rwl->reader_writer_writer_mutex, NULL);

            pthread_mutex_init(&rwl->reader_cnt_mutex, NULL);
            rwl->reader_cnt = 0;
            pthread_mutex_init(&rwl->first_reader_mutex, NULL);
            pthread_mutex_init(&rwl->wait_reader_mutex, NULL);
            rwl->rwl_read_lock = read_write_lock_r_lock_write_first;
            rwl->rwl_read_unlock = read_write_lock_r_unlock_write_first;
            rwl->rwl_write_lock = read_write_lock_w_lock_write_first;
            rwl->rwl_write_unlock = read_write_lock_w_unlock_write_first;
        }
        break;
        default:
            break;
    }
}

/******************************************************************************/
static inline void
read_lock_r_lock(read_write_lock_t *rwl)
{
    rwl->rwl_read_lock(rwl);
}

/******************************************************************************/
static inline void
read_lock_r_unlock(read_write_lock_t *rwl)
{
    rwl->rwl_read_unlock(rwl);
}

static inline void
read_lock_w_lock(read_write_lock_t *rwl)
{
    rwl->rwl_write_lock(rwl);
}

static inline void
read_lock_w_unlock(read_write_lock_t *rwl)
{
    rwl->rwl_write_unlock(rwl);
}

/******************************************************************************/
/******************************************************************************/
/*
 * dpdk的读写锁实现, 显然采用了读者优先的方法, 但其加锁的粒度已经非常的小了
 */
/******************************************************************************/
/******************************************************************************/
#ifdef __DPDK__
typedef struct
{
    volatile int32_t cnt; /**< -1 when W lock held, > 0 when R locks held. */
} rte_rwlock_t;

/******************************************************************************/
static inline void
rte_rwlock_init(rte_rwlock_t *rwl)
{
    rwl->cnt = 0;
}

/******************************************************************************/
static void inline
rte_rwlock_read_lock(rte_rwlock_t *rwl)
{
    int32_t x;
    int success = 0;

    while (success == 0)
    {
        x = rwl->cnt;
        if (x < 0)
        {
            _mm_pause;//节能减排
            continue;
        }
        success = rte_atomic32_cmpset((volatile uint32_t *)&rwl->cnt, x, x+1);
    }
}

static void inline
rte_rwlock_read_unlock(rte_rwlock_t *rwl)
{
    rte_atomic32_dec((rte_atomic32_t *)&rwl->cnt);
}

/******************************************************************************/
static void inline
rte_rwlock_write_lock(rte_rwlock_t *rwl)
{
    int32_t x;
    int success = 0;

    while (success == 0)
    {
        x = rwl->cnt;
        if (x != 0)
        {
            _mm_pause;
            continue;
        }
        success = rte_atomic32_cmpset((volatile uint32_t *)&rwl->cnt, 0, -1);
    }
}
static void inline
rte_rwlock_write_unlock(rte_rwlock_t *rwl)
{
    rte_atomic32_inc((rte_atomic32_t *)&rwl->cnt);
}
#endif
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* __READ_WRITE_LOCK_H__ */
</span>
操作系统经典问题之读者-写者问题
m0_43405302的博客
11-07 438
一、读者-写者问题 一个很好看的小说是由一个著名的作家书写，这篇小说吸引了很多的读者进行阅读。但是如果读者在阅读的时候，作家进来修改文章了，就会导致每个读者看到的内容不同，进而每个人对于这个文章的理解就会有偏差。基于这个问题，一个十分有意思的读者-写者问题诞生了。 二、思路分析 这个问题的思路就是，可以允许多个读者访问这个文件，但是对于写者只能允许当文件里没有读者时，才可以允许写者进入修改文件。除了对文件加上一个互斥锁外，我们还需要一个统计读者的计数参数count。 三、代码实现 int count=0;
二十、经典同步问题-读者写者问题
dragon Fly的博客
10-18 188
文章目录1、读者-写者问题2、哲学家就餐问题 1、读者-写者问题 \qquad动机： 共享数据的访问，假设有两种类型的使用者：一种为读者，不需要修改数据；另一种为写者，其会读取和修改数据。问题的约束包括： 允许在同一时间有多个读者，但在任何时候都只有一个写者；当没有写者时，读者才能访问数据；当没有读者和写者时，写者才能访问数据；在任何时候只能有一个线程可以操作共享变量；读者优先，若在读者前面有写者在排队等待，读者可以越过写者优先进行排队。 \qquad设计算法需要用到的共享数据： 包括数据集，信号量(Cou
经典读者写者问题
scmuzi18的博客
04-07 517
读者：只读数据区中的数据 写者：只往数据区中写数据 要求： （1）允许多个读者同时执行读操作； （2）不允许读者、写者同时操作； （3）不允许多个写者同时操作。 在编写多线程的时候，有种很常见的场景，就是公共数据被修改的机会比较少（即写的几率小），相对写，读的几率反而高，在读的过程中，往往伴随着查找的操作，中间耗时很长。给这种代码段加锁，会极⼤大地降低我们程序的效率。故引入读写锁来解决多
经典同步问题--读者和写者问题
Legendary_life的专栏
09-03 2739
读者--写者问题 读者--写者问题是互斥问题的一个概括。一组并发的线程要访问一个共享的对象，例如一个主存中的数据结构， 或者是磁盘上的数据库。有些线程只读对象，其他线程只修改对象。只读对象的线程叫做读者，修改对象的线 程的对象叫做写者。写者必须拥有对对象的独占的访问，而读者可以和其他读者共享对象。 按照读者和写者的优先级分为两类问题： 一、读者优先 读者优先，要求不要读者等待，
7-3 读者写者饿死问题
C_cai_niao的博客
01-16 1578
参考https://blog.csdn.net/booksyhay/article/details/82762278 在之前的解决方案中，会存在一个问题： 作者可能会饿死。 如果写者到达的时候，临界区中有读者，那么当读者来来往往时，它可能会在队列中等待。只要新读者在最后一位读者离开之前到达，房间里总会有至少一位读者。 这种情况不是僵局，因为一些线程正在取得进展，但这并不是完全可取的。只要系统上的负...
linux 操作系统 多线程编程 经典同步算法--读者写者问题
07-06
有读者和写者两组并发进程，共享一个文件，当两个或以上的读进程同时访问共享数据时不会产生副作用，但若某个写进程和其他进程（读进程或写进程）同时访问共享数据时则可能导致数据不一致的错误。因此要求：①允许多...
通过研究经典的进程同步问题，采用“读写平等”的策略，用信号量 和 PV 操作实现对读者/写者问题的并发控制
04-21
### 通过研究经典的进程同步问题，采用“读写平等”的策略，用信号量和PV操作实现对读者/写者问题的并发控制 #### 一、背景与目标 本设计旨在通过对经典进程同步问题的研究，利用信号量和PV操作来解决读者/写者...
操作系统读者写者问题 详细
03-21
在操作系统中，读者写者问题是一种经典的同步问题。它描述了多个读者进程和写者进程同时访问共享资源的场景，要求读者进程和写者进程之间、读者进程之间、写者进程之间的互斥访问共享资源。 问题描述 在读者写者...
writerandreader.rar_读者写者_读者写者问题
09-22
"读者写者问题"是操作系统领域中的一个经典同步问题，主要涉及到多线程并发控制，以确保多个读者和一个写者能安全地访问共享资源。在这个问题中，多个读者可以同时读取数据，而写者在任何时候只能有一个，并且写者在...
pc.rar_PC问题_读者写者_读者写者问题
09-24
"读者-写者问题"（Reader-Writer Problem）作为一个经典的并发控制问题，旨在解决多个读者和一个写者如何共享同一数据资源，确保在读操作期间能有多个读者同时进行，而在写操作期间必须独占资源。本篇将深入探讨这一...
读者写着问题（读者优先、写者优先）
01-11
操作系统，利用C++来解决读者写者优先问题，内含代码和说明。
两个条件变量实现读写锁，写优先，避免写者饥饿
znHD的博客
08-08 2453
核心思想：用两个int记录写者数与读者数，用两个条件变量分别作为读者、写者的等待队列。 class wfirtst_rwlock { public: wfirtst_rwlock() :rcount(0), wcount(0),writeflag(true) {} void readlock() { unique_lock&lt;mutex&gt; ul(mtx); cond...
INET_HOOK
chris的博客
08-18 271
inet_hook_ops实例 struct inet_hook_ops { //处理函数 inet_hook_fn hook; //Inet hook点，类似linux内核netfilter unsigned int hooknum; //协议族，AF_INET、AF_INET6 int af; //私有数据 void *priv; //优先级,同一hoo..
RTE Read-Write Locks 读写锁函数
qq_22023237的博客
02-28 1518
读写锁特性： 一次只有一个线程可以占有写模式的读写锁, 但是可以有多个线程同时占有读模式的读写锁. 正是因为这个特性, 当读写锁是写加锁状态时, 在这个锁被解锁之前, 所有试图对这个锁加锁的线程都会被阻塞. 当读写锁在读加锁状态时, 所有试图以读模式对它进行加锁的线程都可以得到访问权, 但是如果线程希望以写模式对此锁进行加锁, 它必须直到所有的线程释放锁. 通常, 当读写锁处于读模式锁住状态时, ...
读者写者问题----公平策略(python测试）
antRain的博客
10-15 1772
读者写者问题----公平策略(python测试）问题描述限制条件利用公平策略伪代码测试输出总结 问题描述 一个数据对象若被多个并发进程所共享，且其中一些进程只要求读该数据对象的内容，而另一些 进程则要求写操作，对此，把只想读的进程称为“读者”，而把要求写的进程称为“写者”。在 读者–写着问题中，任何时刻要求“写者”最多只允许有一个，而读者则允许有多个。因为多个 读者的行为互不干扰，他们只是读数据...
DPDK内存管理-----（一）初始化
weixin_30344131的博客
11-06 365
1 前言 DPDK通过使用hugetlbfs，减少CPU TLB表的Miss次数，提高性能。 2 初始化 DPDK的内存初始化工作，主要是将hugetlbfs的配置的大内存页，根据其映射的物理地址是否连续、属于哪个Socket等，有效的组织起来，为后续管理提供便利。 2.1eal_hugepage_info_init() eal_hugepage_info_init()主要是获取配置...
多线程经典问题之读者、写者问题
菜鸟爱学习的博客
12-06 1682
多线程通信之读者、写者问题读、写问题是另一个非常出名的同步问题，常常用来模拟数据库的数据查询和数据修改两种情况问题。也即， 一个数据库允许有多个访问者同时对其进行数据访问，但是对于数据的修改只能有一个。那么如何来控制这种访问多个，而修改只能一个的数据操作方式？这也涉及到线程间通信和同步问题。数据库中存在的情况为： 读者、读者可以同时存在； 读者、写者不能同时存在，如果读者在前，则写者等待；否则所有
哲学家进餐问题pv_PV操作案例（二）——读者、写者；哲学家进餐问题
weixin_33196828的博客
01-17 781
文章目录读者、写者问题描述问题分析哲学家进餐问题描述问题分析读者、写者问题描述有读者和写者两组并发进程，共享一个文件，当两个进程或两个以上的读进程同时访问共享数据时不会产生副作用，但若某个写进程和其他进程(读进程或写进程)同时访问时可能会导致数据不一致的错误。因此要求：①允许多个读者可以同时对文件执行读操作；②只允许一个写者往文件中写信息；③任一写者在完成写操作前不允许其他读者或写者工作；④写者执...
【DPDK】原子操作-rte_atomic32_cmpset解析
楠燊.tech
01-15 1269
DPDK原子操作-cmpset
操作系统中的读者写者问题经典解决方案
资源摘要信息:"读者写者问题，也称为读者-写者问题（Readers-Writers Problem），是操作系统中的一个经典同步问题。该问题探讨的是如何在多个进程访问共享资源时，保证数据的一致性和完整性，特别是当资源被读取和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值