用信号量实现读写锁

最新推荐文章于 2025-04-30 01:20:25 发布
最新推荐文章于 2025-04-30 01:20:25 发布
阅读量2.3k 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： c/c++ 文章标签： struct 测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/kevin_darkelf/article/details/6665027

如何用信号量实现读写锁

方法1

semp.resource = MAX_RESOURCE;

read_lock(semp)
{
    semp.dec(1);
}
~read_lock(semp)
{
    semp.inc(1);
}

write_lock(semp)
{
    semp.dec(MAX_RESOURCE);
}
~write_lock(semp)
{
    semp.inc(MAX_RESOURCE);
}

这种实现有个问题, 写锁可能被饿死, 需要实现写优先.

方法2 

struct rw_lock 
{
    mutex_semp.resource = 1;
    res_semp.resource = MAX_RESOURCE;
};
read_lock(rw_lock)
{
    spin_till(rw_lock.mutex_semp.resource > 0);
    rw_lock.res_semp.dec(1);
}
~read_lock(rw_lock)
{
    rw_lock.res_semp.inc(1);
}
write_lock(rw_lock)
{
    spin_till(rw_lock.mutex_semp.resource > 0);
    rw_lock.mutex_semp.dec(1);
    rw_lock.res_semp.dec(MAX_RESOURCE);
}
~write_lock(rw_lock)
{
    rw_lock.res_semp.inc(MAX_RESOURCE);
    rw_lock.mutex_semp.inc(1);
}
 

需要测试~

 

 

锁与信号量的深度总结与实现【c++与golang】【万字总结】
weixin_44545838的博客
06-09 1967
线程同步和互斥是多线程编程中的两个重要概念，它们都是为了解决多线程环境下的资源共享和访问问题。**线程同步：**线程同步是指多个线程按照一定的顺序执行，以确保在访问共享资源时，不会出现数据不一致的问题。同步机制主要包括条件变量和信号量。**线程互斥：**线程互斥是指在同一时刻，只允许一个线程访问共享资源，以防止数据不一致和竞争条件。互斥锁是实现线程互斥的主要工具。在操作系统中，锁、条件变量和信号量都是用来实现线程同步与互斥的机制。锁（Lock）是一种互量，用于保护共享资源，防止多个线程同时访问。
C/C++用信号量、自旋锁、读写锁实现互斥锁功能
xiaofeng的博客
10-11 516
linux 多线程 **展开查看源码** 展开的内容及代码块 [code=BatchFile][/code]
信号量实现读写锁
hardworkba的专栏
07-31 1993
/*  * 一般的读写锁：  * 一般的读写锁都是一开始对锁分配MAX_RESOURCE个资源，其中写操作的时候会一次性占用  * MAX_RESOURCE个资源，而读操作的时候就只会占用一个资源。这样子会出现一个问题就是  * 如果在当前资源的数目不为MAX_RESOURCE的时候，那么总是不能进行写操作，只能是进行  * 读操作，如果不停的有读操作的话，那么就无法进行写操作，那么就是
Linux多线(进)程编程——番外2：信号量实现读写锁
最新发布
Mr_Hanc_Tiskor的博客
04-30 1052
对于数据库（可以看作共享内存）等高并发的服务器，需要同时应对很多请求，这些请求里有读请求也有写请求。如果每次来一个请求的时候就给数据库加一个锁，或者使用单一信号量限制单进程访问，那么系统的性能会受到极大的影响，失去多进程的优势。为了解决这个问题，可以考虑使用读写锁。
实现线程读写锁的四种方法
热门推荐
LUCKYOJ
05-07 1万+
对于某个临界互斥资源， 读写锁：当已经被加了读锁时，其他的读模式锁请求仍然可以访问，但是写模式锁不能访问；当写模式锁加锁时，其他的请求都不能访问。
利用进程信号量实现读写锁
HappyMrSpring
02-22 1256
static struct sembuf hms_rl[2] = { {0, -1, SEM_UNDO}, {0, 2, SEM_UNDO} static struct sembuf hms_wl[2] = { {0, -1, SEM_UNDO}, {0, 0, SEM_UNDO} }; static struct sembuf hms_url[1] = { {0, -1, SEM_...
TrReadWriteLock:使用互斥量和信号量编写的简单Objective-C读写锁库
04-29
TrReadWriteLock是使用pthread信号量的读写器锁定实现。 它是完全递归的（读和写）。 读者-作家锁定用于多线程环境，并允许多个线程同时读取一块共享内存，但一次只能写入一个线程。 该库已创建，可以在使用代码中...
linux学习：线程安全（信号量+互斥锁读写锁+条件变量+可重入函数）
weixin_59669309的博客
04-29 1120
这样的信号量其实是一个特殊的文件，创建成功之后将会被放置在系统的一个特殊的 虚拟文件系统/dev/shm 之中，不同的进程间只要约定好一个相同的名字，他们就可以通 过这种有名信号量来相互协调，在进程退出之后 他们并不会自动消失，而需要手工删除并释放资源。信号量分为两种，分别是无名信号量和有名信号量， 这两种信号量比之前介绍的 system-V 的信号量机制要简洁，虽然没有后者的应用范围那么广泛，但是 POSIX 良好的设计使得他们更具吸引力。使用条件变量，来实现前面所述的小楠和她的兄弟姐妹取钱的逻辑。
Linux内核读写锁与读写信号量的区别及选用
阿东的学习记录
02-20 322
是两种不同的同步机制，适用于不同的场景。在Linux内核中，读写锁（
基于c++内存池,共享内存和信号量实现高速的进程间通信队列,单进程读单进程写无需加锁，多进程读多进程写用信号量集实现读写锁
07-30
在多进程读写场景下，信号量可以实现读写锁，防止数据竞争。在本项目中，当有多个进程试图写入队列时，信号量可以确保一次只有一个进程写入，同时允许多个进程进行读取。同样，对于读取操作，如果存在多个进程，信号...
利用条件信号量设计读写锁
weixin_30294709的博客
10-19 198
1 一个资源同时可以有多个读写，但是只能有一个写锁 2 用flag代表锁的状态， #define un_lock 0 #define r_lock1 //上一把读锁加一个r_lock #define w_lock -1 伪代码 1 LOCK_R pthread_lock(resource.mutex) while(resource.flag&l...
利用信号实现写优先的读写锁
weixin_30387339的博客
09-24 180
　　以前利用linux系统提供的读写锁写过一些小程序，但是linux系统提供的读写锁是线程级的，如果是进程间的同步的话，就没那么轻松了。而且由于linux系统提供的读写锁是读优先的，在有些情况下，也不能满足我们的要求。下面就说说利用信号量来实现写优先的读写锁。 　　先说说原理，这个程序需要用到两个信号量，一个互斥信号量A，一个同步信号量B，其拥有MAX_RESOURCES个资源。当读进...
Linux Posix信号量 读写锁
ChristianMw的博客
07-28 262
POSIX信号量 sem_t sem_init() int sem_init(sem_t *sem, int pshared, unsigned int value); 参数：pshared:0表⽰示线程间共享，⾮非零表⽰示进程间共享 value：信号量初始值 sem_wait() 条件不满足，等待 sem_post() 通知 sem_destroy() #inclu...
信号量和读写锁
qq_43205670的博客
04-28 574
信号量: 具有等待队列的计数器, 做什么:实现进程/线程间同步与互斥 计数器用于判断现在是否有资源信号量有更多的计数–>标记有多少资源是否可以操作–>实现同步:–>唤醒和等待 信号量: 功能计数大于0代表有资源可以操作(-1)往下走返回(内部对计数减1操作),代表资源被使用之后,操作完毕之后,唤醒,回收,然后释放资源(计数器+1)通知队列上的pcb资源空出一个,将互斥锁的计数和条...
张氏读写锁，c++信号量实现
张人杰的博客
12-19 711
ReadWriteLock.h #pragma once #include class ReadWriteLock { public: ReadWriteLock(void); ~ReadWriteLock(void); void LockRead(void); void LockWrite(void); std::mutex m_lock_writeCount;
自旋锁、互斥锁、信号量、读写锁、递归锁、乐观锁、悲观锁的底层实现
u011495684的博客
06-22 944
自旋锁、互斥锁、信号量、读写锁、递归锁、乐观锁、悲观锁(一) 我们知道 每个操作系统都有这样一些锁，各个锁之间好像可以互相转换，但概念上又总是模棱两可。下面从Linux系统对这些锁的实现方式下手，谈一下这些锁之间的联系。 原子性:一条汇编指令的执行过程中是原子性的，cpu不可能将一条汇编语言执行一半，然后去执行别的汇编指令。这称为原子性，及，一条汇编语言就是cpu最小的执行时间单位，不可以分割，执行的时候不可暂停。因此，实现单一变量的原子读写操作是容易的，只要保证读写操作只对应一条汇编语言即可。 但是，很多
随笔---信号量实现，读共享，读写互斥，写写互斥,读优先，锁模型
茄子的博客
07-01 161
class ReadWriter{ int Rcount=0; Semaphore WriteSem = new Semaphore(1); Semaphore ReadSem = new Semaphore(1); Data data;//数据 public void writerMethod(data){ WtireSem.wait() } }
信号量Semaphore,读写锁ReadWriteLock,计数器CountDownLatch,循环栅栏CyclicBarrier运用
欣淡定的博客
01-06 545
1.信号量Semaphore: 像synchronized, ReentrantLock等这些对临界区资源进行同步后,所有对临界区资源进行访问的线程都得串行排队,而信号量允许指定的线程数同时进行访问 demo: import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import ...
基于rt thread 的信号量实现读写锁的控制结构体和相关API函数
06-06
RT-Thread中可以使用信号量实现读写锁，具体实现方式如下所示： ```c /* 定义读写锁结构体 */ typedef struct { rt_sem_t lock; // 读写锁信号量 rt_sem_t write_sem; // 写入信号量 int reader_count; // 读者数量 } rt_rwlock_t; /* 初始化读写锁 */ void rt_rwlock_init(rt_rwlock_t *rwlock) { rwlock->lock = rt_sem_create("rwlock", 1, RT_IPC_FLAG_FIFO); // 初始化为1，表示可用 rwlock->write_sem = rt_sem_create("write_sem", 1, RT_IPC_FLAG_FIFO); rwlock->reader_count = 0; } /* 获取读锁 */ void rt_rwlock_read_lock(rt_rwlock_t *rwlock) { rt_sem_take(rwlock->lock, RT_WAITING_FOREVER); // 加锁，防止其他线程修改reader_count rwlock->reader_count++; if (rwlock->reader_count == 1) { rt_sem_take(rwlock->write_sem, RT_WAITING_FOREVER); // 如果是第一个读者，需要获取写入锁 } rt_sem_release(rwlock->lock); // 解锁 } /* 释放读锁 */ void rt_rwlock_read_unlock(rt_rwlock_t *rwlock) { rt_sem_take(rwlock->lock, RT_WAITING_FOREVER); // 加锁，防止其他线程修改reader_count rwlock->reader_count--; if (rwlock->reader_count == 0) { rt_sem_release(rwlock->write_sem); // 如果没有读者了，释放写入锁 } rt_sem_release(rwlock->lock); // 解锁 } /* 获取写锁 */ void rt_rwlock_write_lock(rt_rwlock_t *rwlock) { rt_sem_take(rwlock->write_sem, RT_WAITING_FOREVER); // 获取写入锁 } /* 释放写锁 */ void rt_rwlock_write_unlock(rt_rwlock_t *rwlock) { rt_sem_release(rwlock->write_sem); // 释放写入锁 } ``` 上述代码中，读写锁结构体包含一个读写锁信号量、一个写入信号量、一个读者数量。在获取读锁时，需要先获取读写锁信号量，然后增加读者数量，如果是第一个读者，需要获取写入信号量。在释放读锁时，需要先获取读写锁信号量，然后减少读者数量，如果没有读者了，需要释放写入信号量。在获取写锁时，只需要获取写入信号量。在释放写锁时，只需要释放写入信号量。 需要注意的是，在使用读写锁时，需要确保读者和写者之间的互斥性，即不能同时存在读者和写者。因此，在获取写锁时，需要等待所有的读者完成读操作后才能获取锁。这里的实现方式是使用了一个写入信号量来实现这个功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值