使用读写锁

最新推荐文章于 2025-02-14 09:19:09 发布
原创 最新推荐文章于 2025-02-14 09:19:09 发布 · 1.7k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#solaris #null #c

使用读写锁

配置读写锁的属性之后，即可初始化读写锁。以下函数用于初始化或销毁读写锁、锁定或解除锁定读写锁或尝试锁定读写锁。下表列出了本节中讨论的用来处理读写锁的函数。

表 4–9 处理读写锁的例程


操作

相关函数说明

初始化读写锁

pthread_rwlock_init 语法

读取读写锁中的锁

pthread_rwlock_rdlock 语法

读取非阻塞读写锁中的锁

pthread_rwlock_tryrdlock 语法

写入读写锁中的锁

pthread_rwlock_wrlock 语法

写入非阻塞读写锁中的锁

pthread_rwlock_trywrlock 语法

解除锁定读写锁

pthread_rwlock_unlock 语法

销毁读写锁

pthread_rwlock_destroy 语法

 

初始化读写锁

使用 pthread_rwlock_init(3C) 可以通过 attr 所引用的属性初始化 rwlock 所引用的读写锁。

pthread_rwlock_init 语法

#include <pthread.h>



int pthread_rwlock_init(pthread_rwlock_t *rwlock, 

        const pthread_rwlockattr_t *attr);



pthread_rwlock_t  rwlock = PTHREAD_RWLOCK_INITIALIZER;

如果 attr 为 NULL，则使用缺省的读写锁属性，其作用与传递缺省读写锁属性对象的地址相同。初始化读写锁之后，该锁可以使用任意次数，而无需重新初始化。成功初始化之后，读写锁的状态会变为已初始化和未锁定。如果调用 pthread_rwlock_init() 来指定已初始化的读写锁，则结果是不确定的。如果读写锁在使用之前未初始化，则结果是不确定的。对于 Solaris 线程，请参见rwlock_init 语法。

如果缺省的读写锁属性适用，则 PTHREAD_RWLOCK_INITIALIZER 宏可初始化以静态方式分配的读写锁，其作用与通过调用 pthread_rwlock_init() 并将参数 attr 指定为 NULL 进行动态初始化等效，区别在于不会执行错误检查。

pthread_rwlock_init 返回值

如果成功，pthread_rwlock_init() 会返回零。否则，将返回用于指明错误的错误号。

如果 pthread_rwlock_init() 失败，将不会初始化 rwlock，并且 rwlock 的内容是不确定的。

EINVAL

描述:

attr 或 rwlock 指定的值无效。

获取读写锁中的读锁

pthread_rwlock_rdlock(3C) 可用来向 rwlock 所引用的读写锁应用读锁。

pthread_rwlock_rdlock 语法

#include <pthread.h>



int  pthread_rwlock_rdlock(pthread_rwlock_t *rwlock );

如果写入器未持有读锁，并且没有任何写入器基于该锁阻塞，则调用线程会获取读锁。如果写入器未 持有读锁，但有多个写入器正在等待该锁时，调用线程是否能获取该锁是不确定的。如果某个写入器持有读锁，则调用线程无法获取该锁。如果调用线程未获取读 锁，则它将阻塞。调用线程必须获取该锁之后，才能从 pthread_rwlock_rdlock() 返回。如果在进行调用时，调用线程持有 rwlock 中的写锁，则结果是不确定的。

为避免写入器资源匮乏，允许在多个实现中使写入器的优先级高于读取器。例如，Solaris 线程实现中写入器的优先级高于读取器。 请参见rw_rdlock 语法。

一个线程可以在 rwlock 中持有多个并发的读锁，该线程可以成功调用 pthread_rwlock_rdlock() n 次。该线程必须调用 pthread_rwlock_unlock() n 次才能执行匹配的解除锁定操作。

如果针对未初始化的读写锁调用 pthread_rwlock_rdlock()，则结果是不确定的。

线程信号处理程序可以处理传送给等待读写锁的线程的信号。从信号处理程序返回后，线程将继续等待读写锁以执行读取，就好像线程未中断一样。

pthread_rwlock_rdlock 返回值

如果成功，pthread_rwlock_rdlock() 会返回零。否则，将返回用于指明错误的错误号。

EINVAL

描述:

attr 或 rwlock 指定的值无效。

读取非阻塞读写锁中的锁

pthread_rwlock_tryrdlock(3C) 应用读锁的方式与 pthread_rwlock_rdlock() 类似，区别在于如果任何线程持有 rwlock 中的写锁或者写入器基于 rwlock 阻塞，则 pthread_rwlock_tryrdlock() 函数会失败。对于 Solaris 线程，请参见rw_tryrdlock 语法。

pthread_rwlock_tryrdlock 语法

#include <pthread.h>



int pthread_rwlock_tryrdlock(pthread_rwlock_t *rwlock);

pthread_rwlock_tryrdlock 返回值

如果获取了用于在 rwlock 所引用的读写锁对象中执行读取的锁，则 pthread_rwlock_tryrdlock() 将返回零。如果没有获取该锁，则返回用于指明错误的错误号。

EBUSY

描述:

无法获取读写锁以执行读取，因为写入器持有该锁或者基于该锁已阻塞。

写入读写锁中的锁

pthread_rwlock_wrlock(3C) 可用来向 rwlock 所引用的读写锁应用写锁。

pthread_rwlock_wrlock 语法

#include <pthread.h>



int  pthread_rwlock_wrlock(pthread_rwlock_t *rwlock );

如果没有其他读取器线程或写入器线程持有读写锁 rwlock，则调用线程将获取写锁。否则，调用线程将阻塞。调用线程必须获取该锁之后，才能从 pthread_rwlock_wrlock() 调用返回。如果在进行调用时，调用线程持有读写锁（读锁或写锁），则结果是不确定的。

为避免写入器资源匮乏，允许在多个实现中使写入器的优先级高于读取器。（例如，Solaris 线程实现允许写入器的优先级高于读取器。请参见rw_wrlock 语法。）

如果针对未初始化的读写锁调用 pthread_rwlock_wrlock()，则结果是不确定的。

线程信号处理程序可以处理传送给等待读写锁以执行写入的线程的信号。从信号处理程序返回后，线程将继续等待读写锁以执行写入，就好像线程未中断一样。

pthread_rwlock_wrlock 返回值

如果获取了用于在 rwlock 所引用的读写锁对象中执行写入的锁，则 pthread_rwlock_rwlock() 将返回零。如果没有获取该锁，则返回用于指明错误的错误号。

写入非阻塞读写锁中的锁

pthread_rwlock_trywrlock(3C) 应用写锁的方式与 pthread_rwlock_wrlock() 类似，区别在于如果任何线程当前持有用于读取和写入的 rwlock，则 pthread_rwlock_trywrlock() 函数会失败。对于 Solaris 线程，请参见 rw_trywrlock 语法。

pthread_rwlock_trywrlock 语法

#include <pthread.h>



int pthread_rwlock_trywrlock(pthread_rwlock_t  *rwlock);

如果针对未初始化的读写锁调用 pthread_rwlock_trywrlock()，则结果是不确定的。

线程信号处理程序可以处理传送给等待读写锁以执行写入的线程的信号。从信号处理程序返回后，线程将继续等待读写锁以执行写入，就好像线程未中断一样。

pthread_rwlock_trywrlock 返回值

如果获取了用于在 rwlock 引用的读写锁对象中执行写入的锁，则 pthread_rwlock_trywrlock() 将返回零。否则，将返回用于指明错误的错误号。

EBUSY

描述:

无法为写入获取读写锁，因为已为读取或写入锁定该读写锁。

解除锁定读写锁

pthread_rwlock_unlock(3C) 可用来释放在 rwlock 引用的读写锁对象中持有的锁。

pthread_rwlock_unlock 语法

#include <pthread.h>



int pthread_rwlock_unlock (pthread_rwlock_t  *rwlock);

如果调用线程未持有读写锁 rwlock，则结果是不确定的。对于 Solaris 线程，请参见rw_unlock 语法。

如果通过调用 pthread_rwlock_unlock() 来释放读写锁对象中的读锁，并且其他读锁当前由该锁对象持有，则该对象会保持读取锁定状态。如果 pthread_rwlock_unlock() 释放了调用线程在该读写锁对象中的最后一个读锁，则调用线程不再是该对象的属主。如果 pthread_rwlock_unlock() 释放了该读写锁对象的最后一个读锁，则该读写锁对象将处于无属主、解除锁定状态。

如果通过调用 pthread_rwlock_unlock() 释放了该读写锁对象的最后一个写锁，则该读写锁对象将处于无属主、解除锁定状态。

如果 pthread_rwlock_unlock() 解除锁定该读写锁对象，并且多个线程正在等待获取该对象以执行写入，则通过调度策略可确定获取该对象以执行写入的线程。如果多个线程正在等待获取读写锁对象以执行读取，则通过调度策略可确定等待线程获取该对象以执行写入的顺序。如果多个线程基于 rwlock 中的读锁和写锁阻塞，则无法确定读取器和写入器谁先获得该锁。

如果针对未初始化的读写锁调用 pthread_rwlock_unlock()，则结果是不确定的。

pthread_rwlock_unlock 返回值

如果成功，pthread_rwlock_unlock() 会返回零。否则，将返回用于指明错误的错误号。

销毁读写锁

pthread_rwlock_destroy(3C) 可用来销毁 rwlock 引用的读写锁对象并释放该锁使用的任何资源。

pthread_rwlock_destroy 语法

#include <pthread.h>



int pthread_rwlock_destroy(pthread_rwlock_t *rwlock);



pthread_rwlock_t  rwlock = PTHREAD_RWLOCK_INITIALIZER;

在再次调用 pthread_rwlock_init() 重新初始化该锁之前，使用该锁所产生的影响是不确定的。实现可能会导致 pthread_rwlock_destroy() 将 rwlock 所引用的对象设置为无效值。如果在任意线程持有 rwlock 时调用 pthread_rwlock_destroy()，则结果是不确定的。尝试销毁未初始化的读写锁会产生不确定的行为。已销毁的读写锁对象可以使用 pthread_rwlock_init() 来重新初始化。销毁读写锁对象之后，如果以其他方式引用该对象，则结果是不确定的。对于 Solaris 线程，请参见rwlock_destroy 语法。

pthread_rwlock_destroy 返回值

如果成功，pthread_rwlock_destroy() 会返回零。否则，将返回用于指明错误的错误号。

EINVAL

描述:

attr 或 rwlock 指定的值无效。

Golang高并发场景下读写锁的正确使用姿势
Golang编程笔记的博客
05-11 1054
在高并发的应用程序中，多个协程（goroutine）可能会同时访问共享资源。为了保证数据的一致性和正确性，需要对共享资源的访问进行同步控制。读写锁（RWMutex）是一种特殊的锁，它允许多个协程同时进行读操作，但在写操作时会独占资源，从而提高并发性能。本文的目的是深入探讨Golang中读写锁的原理、使用方法以及在高并发场景下的正确使用方式，范围涵盖了读写锁的基本概念、算法原理、实际应用等方面。本文将按照以下结构进行组织：首先介绍读写锁的背景知识，包括目的、适用读者群体和文档结构等。
linux下实现高性能读写锁（read/write lock）
07-07
在linux下按照windows的slim read/write lock算法实现的读写锁源码。
读写锁pthread_rwlock_t的使用
热门推荐
wonderisland的专栏
11-25 4万+
读写锁是用来解决读者写者问题的，读操作可以共享，写操作是排他的，读可以有多个在读，写只有唯一个在写，同时写的时候不允许读。 具有强读者同步和强写者同步两种形式 强读者同步：当写者没有进行写操作，读者就可以访问； 强写者同步：当所有写者都写完之后，才能进行读操作，读者需要最新的信息，一些事实性较高的系统可能会用到该所，比如定票之类的。 读写锁的操作： 读写锁的初始化：  
读写锁的使用
littore的专栏
06-12 485
import java.util.Date; import java.util.Random; import java.util.concurrent.locks.ReentrantReadWriteLock; /**  *    * 读写锁：ReadWriteLock  *    * 在多线程的环境下，对同一份数据进行读写，会涉及到线程安全的问题。比如在一个线程读取数据的时候，
linux 读写锁使用 pthread_rwlock_t
u013921164的博客
05-21 694
因在项目中，多线程对某记忆文件读写偶发错误，想着加锁来解决。文件读写锁无疑是一个非常好的选择 头文件： #include <pthread.h> 初始化 pthread_rwlock_init(&rw_lock, nullptr); //初始化读写锁 pthread_rwlock_wrlock(&rw_lock); pthread_rwlock_unlock(&rw_lock); //解锁 ...
C#解决SQlite并发异常问题的方法(使用读写锁)
09-02
C#中解决SQLite数据库并发异常问题的方法主要涉及到多线程环境下读写锁的使用。SQLite是一个轻量级的文件型数据库，它在设计上通过文件锁来管理并发访问。这意味着多个线程可以同时进行读操作，但在同一时间内只有一...
C#使用读写锁三行代码简单解决多线程并发的问题
09-01
本文通过三行代码展示了如何使用读写锁解决多线程并发写入文件的冲突。 读写锁的核心在于，它允许多个线程同时读取资源，但只允许一个线程写入资源。这样，当多个线程尝试写入时，只有一个线程能够获得写锁，其他...
linux读写锁pthread_rwlock_t
weixin_40355471的博客
03-26 1069
pthread_rwlock_t g_rwlock; // 定义一把读写锁pthread_rwlock_init(&g_rwlock, NULL); // 初始化读写锁pthread_rwlock_rdlock(&g_rwlock); // 请求读锁pthread_rwlock_wrlock(&g_rwlock); // 请求写锁pthread_rwlock_unlock(&g_rwlock); // 解锁pthread_rwlock_destroy(&g_rwlock);// 销毁读写锁，设置读写优先级
linux进阶51——pthread_rwlock_t(读写锁)
www_dong的博客
09-05 9148
1. 概念 读写锁与互斥量类似。但是互斥量要么是锁住状态，要么就是不加锁状态，而且一次只有一个线程可以对其加锁 不过读写锁允许更高的并行性，而且有更多的状态 读写锁可以有3种状态： ①读模式下加锁 ②写模式下加锁 ③不加锁状态 2. 使用 当读写锁是写加锁状态时：在这个锁被解锁之前，所有试图对这个锁加锁的线程都会阻塞（不论是读还是写） 当读写锁是读加锁状态时：所有试图以读模式对它进行加锁的线程都可以得到访问权。但是任何希望以写模式对此锁进行加锁的线程都会阻塞，直到所有的线程释放它们的读锁为止
linux使用读写锁pthread_rwlock_t
金溪的博客
08-29 371
初始化读写锁 int pthread_rwlock_init(pthread_rwlock_t *rwlock, const pthread_rwlockattr_t *attr); 如果attr为null, 则使用缺省的读写锁属性, 如果缺省的读写锁属性适用, 则PTHREAD_RWLOCK_INITIALIZER宏可初始化以静态方式分配的读写锁, 其作用与通过pthr...
【Linux】vscode 对 pthread_rwlock_t 等报错 解决方法
weixin_46512400的博客
07-20 1545
在Linux环境下使用 VScode 编写C代码，在进行关于进程、现程开发的时候，一些系统调用或者定义（比如像等) 编辑器都无法解析出来，经常会出现无法跳转函数定义、飘红等，除了没有 include 相关的头文件之外，很可能是没有进行宏定义导致的 VScode 解析器无法识别。
【Linux系统编程】多线程编程：线程同步机制-rwlock(读写锁)
Stark的博客
02-14 777
读写锁（Readers-Writer Lock）是一种多线程同步机制，用于控制对共享资源的访问。与传统的互斥锁（Mutex）不同，它允许多个读操作同时进行，但写操作必须独占访问。这可能比普通的互斥锁更高效，特别是在读多写少的场景下。使用读写锁的场景通常包括共享数据结构如缓存、数据库等。比如，一个数据库系统中，如果读请求（如查询）远大于写请求（如更新），使用读写锁可以让多个查询线程并行访问数据，从而提升系统的响应速度。
pthread_rwlock_t 使用demo
flying_ant2018的博客
01-19 499
【代码】pthread_rwlock_t 使用demo。
读写锁的使用规则
weixin_48256350的博客
03-28 982
读写锁： 读锁（共享锁） —> 访问临界资源，可以一起读取数据 --> 读锁可以同时上，不会阻塞！ 写锁（互斥锁） —> 访问临界资源时，不要一起修改值 --> 写锁不能同时上锁,会阻塞！ 1. 初始化读写锁 – pthread_rwlock_init() -> man 3 pthread_rwlock_init #include <pthread.h> int pthread_rwlock_init(pthread_rwlock_
linux_线程读写锁_pthread_rwlock_rdlock函数_pthread_rwlock_wrlock函数_pthread_rwlock_tryrdlock函数_pthread_rwloc
qq_44177918的博客
05-02 1887
pthread_rwlock_tryrdlock函数 pthread_rwlock_trywrlock函数 读写锁是“读模式加锁”时， 既有试图以写模式加锁的线程，也有试图以读模式加锁的线程。那么读写锁会阻塞随后的读模式锁请求。今天来向大家分享linux的另一种锁：读写锁，与互斥量锁类似，但读写锁允许更高的并行性。读写锁也叫共享-独占锁。 读写锁是“读模式加锁”时， 如果线程以读模式对其加锁会成功；3个线程不定时 “写” 全局资源，5个线程不定时 “读” 同一全局资源。 读写锁是“写模式加锁”时， 解锁前，
linux读写锁
oguro的博客
12-25 818
读写锁 与互斥量类似，但读写锁允许更高的并行性。其特性为：写独占，读共享。 读写锁状态： 一把读写锁具备三种状态： 1. 读模式下加锁状态 (读锁) 2. 写模式下加锁状态 (写锁) 3. 不加锁状态 读写锁特性： 1. 读写锁是“写模式加锁”时， 解锁前，所有对该锁加锁的线程都会被阻塞。 2. 读写锁是“读模式加锁”时， 如果线程以读模式对其加锁会成功；如果线程以写模式加
linux线程同步方式5——读写锁（rwlock）
JMW1407的博客
06-17 3470
读写锁（rwlock）读写锁1、背景和定义1. 背景：读者和写者问题2. 定义3. 读写锁三种状态4. 读写锁特性2、初始化3、请求读锁(阻塞)4、请求读锁(非阻塞)5、请求写锁（阻塞）6、请求写锁（非阻塞）7、解锁8、销毁互斥锁、读写锁、自旋锁区别应用举例参考 读写锁 #include <pthread.h> 1、背景和定义 1. 背景：读者和写者问题 有一群写者和一群读者，写者在写同一本书，读者也在读这本书，多个读者可以同时读这本书，但是，只能有一个写者在写书。特征： （1）任意多的读进
springboot 中使用读写锁
最新发布
05-31
<think>好的，我现在需要帮用户解决在SpringBoot项目中实现读写锁的问题。用户提到了ReentrantReadWriteLock，所以我得先回忆一下这个类的相关知识。根据引用[2]和[3]，ReentrantReadWriteLock的读锁和写锁是通过内部的Sync类实现的，读锁和写锁是分开的两个类，分别由ReadLock和WriteLock提供。同时，引用[4]提到，这种锁在读多写少的场景下能提高并发性能，因为多个读锁可以共存，而写锁是独占的。首先，用户需要示例代码和使用方法。我应该考虑如何在Spring Boot中正确创建ReentrantReadWriteLock实例，并在服务类中使用它。通常，在Spring Boot中，我们会将这样的逻辑放在Service层，所以需要创建一个Service类，并在其中注入或实例化读写锁。然后，要注意Java中的ReentrantReadWriteLock的使用规范。根据引用[3]，读锁和写锁是通过内部类实现的，需要分别获取。在使用时，必须遵循获取锁后一定要在finally块中释放锁，以避免死锁。同时，引用[1]提到锁降级的概念，可能需要说明如何实现锁降级，但用户的问题可能更偏向基础使用，所以示例代码可以简单展示读锁和写锁的基本用法。 接下来，考虑代码结构。在Spring Boot中，通常使用@Service注解来标记服务类。因此，我会创建一个如ReadWriteLockService的类，其中包含ReentrantReadWriteLock的实例，以及读和写的方法。每个方法中，先获取锁，执行操作，然后释放锁。例如，读操作使用readLock().lock()，写操作使用writeLock().lock()，并在finally块中解锁。 另外，用户可能需要知道如何在实际业务中应用，比如缓存管理或数据同步。这时候可以举一个缓存更新的例子，展示读锁和写锁如何配合，确保数据的一致性。例如，在读取缓存时获取读锁，允许并发读取；而在更新缓存时获取写锁，独占访问，防止读写冲突。 还需要注意事务管理的问题，但可能用户暂时不需要复杂的事务整合，所以示例代码可以保持简单，专注于锁的使用。同时，要提醒可能出现的线程安全问题，比如锁的顺序，避免死锁，以及锁的公平性设置，根据需求选择合适的构造函数（公平或非公平）。最后，生成相关问题，帮助用户深入理解。比如性能分析、优化方法、应用场景等，这些都是自然延伸的问题，可以引导用户进一步学习。</think>在Spring Boot项目中实现读写锁可以通过`ReentrantReadWriteLock`实现，以下是具体实现方法和示例代码： --- ### 一、实现步骤 1. **创建Service类**：封装读写操作 2. **初始化读写锁**：使用`ReentrantReadWriteLock` 3. **定义读/写方法**：通过`readLock()`和`writeLock()`控制并发 --- ### 二、示例代码 ```java @Service public class ReadWriteLockService { // 初始化读写锁 private final ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock(); private String sharedResource = "原始数据"; // 读操作（允许多线程并发） public String readResource() { rwLock.readLock().lock(); // 获取读锁 try { // 模拟耗时操作 Thread.sleep(100); return sharedResource; } catch (InterruptedException e) { Thread.currentThread().interrupt(); return "读取中断"; } finally { rwLock.readLock().unlock(); // 释放读锁[^2] } } // 写操作（独占执行） public void writeResource(String newValue) { rwLock.writeLock().lock(); // 获取写锁 try { // 模拟耗时操作 Thread.sleep(200); sharedResource = newValue; } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { rwLock.writeLock().unlock(); // 释放写锁[^3] } } } ``` --- ### 三、使用场景示例（缓存管理） ```java @Service public class CacheService { private final ReentrantReadWriteLock lock = new ReentrantReadWriteLock(); private Map<String, Object> cache = new HashMap<>(); // 读取缓存（并发安全） public Object getFromCache(String key) { lock.readLock().lock(); try { return cache.get(key); } finally { lock.readLock().unlock(); } } // 更新缓存（独占更新） public void updateCache(String key, Object value) { lock.writeLock().lock(); try { cache.put(key, value); } finally { lock.writeLock().unlock(); } } } ``` --- ### 四、关键注意事项 1. **锁释放**：必须通过`try-finally`确保锁释放 2. **锁降级**：可通过先获取写锁再获取读锁实现[^1] 3. **公平性**：构造函数可指定`new ReentrantReadWriteLock(true)`实现公平锁 4. **性能监控**：可通过`getQueueLength()`监控等待线程数 ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值