java多线程:并发包中ReentrantReadWriteLock读写锁的原理

一:读写锁解决的场景问题
--->数据的读取频率远远大于写的频率的场景,就可以使用读写锁。
二:读写锁的结构
--->用state一个变量。将其转化成二进制,前16位为高位,标记读线程获取锁的次数。后16位为低位,标记写线程获取锁的次数。
--->读写锁需要解决的冲突:读/写冲突,写/写冲突。读/读之间无冲突。
--->当有写线程获取锁的时候。state的二进制表现,低位有数字,高位全是0。当有读线程获取锁的时候,state的二进制表现,低位全是0,高位有数字。
--->如何获取读线获取锁的次数呢?将state>>16得到的结果。如何获取写线程获取锁的次数呢?state&0x0000FFFF做按位与运算得到的结果。

三:读写锁的公平和非公平模式
非公平模式(默认):连续竞争的非公平锁可能无限期地推迟一个或多个reader或writer线程,但吞吐量通常要高于公平锁。
公平模式:线程利用一个近似到达顺序的策略来争夺进入。当释放当前保持的锁时,可以为等待时间最长的单个writer线程分配写入锁,如果有一组等待时间大于所有正在等待的writer线程的reader,将为该组分配读者锁。
试图获得公平写入锁的非重入的线程将会阻塞,除非读取锁和写入锁都自由(这意味着没有等待线程)。
四:重入

--->此锁允许reader和writer按照 ReentrantLock 的样式重新获取读取锁或写入锁。在写入线程保持的所有写入锁都已经释放后,才允许重入reader使用读取锁。

五:写线程小于读线程的数量的时候,当写线程想获取锁的时候,如何提高写线程获取锁的概率。通过后继节点是否是共享节点机制实现。
--->当读写锁底层的同步管理器为公平锁时,则严格按照顺序进行获取锁,当然读线程可以同时获取锁 体现在:readerShouldBlock()
--->当读写锁底层的同步管理器为非公平锁时,则当下一个节点为写线程的节点,则当前获取锁的读线程则阻塞。提高写线程获取锁的概率。体现在readerShouldBlock()
--->写线程形成的Node为排它节点。读线程形成的Node为共享节点。区别在于Node内部的属性nextWaiter的属性引用,若引用为null则为排它节点。若引用为Node.SHARED则为共享节点。

六:读写锁的一些特性
writer可以获取读取锁,但reader不能获取写入锁。
锁降级:重入还允许从写入锁降级为读取锁,实现方式是:先获取写入锁,然后获取读取锁,最后释放写入锁。但是,从读取锁升级到写入锁是不可能的。
锁获取的中断:读取锁和写入锁都支持锁获取期间的中断。

锁降级中读锁的获取是否必要呢?

--->答案是必须的。主要是为了保证数据的可见性,如果当前线程不获取读锁而直接释放写锁,假设此刻另一个线程(记作线程T)获取了写锁并修改了数据,那么当前线程无法感知线程T的数据更新。如果当前线程获取读锁,即遵循锁降级的步骤,则线程T将会被阻塞,直到当前线程使用数据并释放读锁之后,线程T才能获取写锁进行更新。

 

Condition 支持:写入锁提供了一个 Condition 实现,对于写入锁来说,该实现的行为与 ReentrantLock.newCondition() 提供的 Condition 实现对 ReentrantLock 所做的行为相同。当然,此 Condition 只能用于写入锁。
读取锁不支持 Condition,readLock().newCondition() 会抛出 UnsupportedOperationException。
监测:此类支持一些确定是读取锁还是写入锁的方法。这些方法设计用于监视系统状态,而不是同步控制

七:读锁,获取锁和释放锁的原理图

八读锁的获取和释放

时间: 2024-12-13 01:54:16

java多线程:并发包中ReentrantReadWriteLock读写锁的原理的相关文章

java多线程:并发包中ReentrantReadWriteLock读写锁的锁降级模板

写锁降级为读锁,但读锁不可升级或降级为写锁. 锁降级是为了让当前线程感知到数据的变化. 1 //读写锁 2 private ReentrantReadWriteLock lock=new ReentrantReadWriteLock(); 3 //读锁 4 private ReadLock readLock=lock.readLock(); 5 //写锁 6 private WriteLock writeLock=lock.writeLock(); 7 private boolean updat

Java 并发包中的读写锁及其实现分析

1. 前言 在Java并发包中常用的锁(如:ReentrantLock),基本上都是排他锁,这些锁在同一时刻只允许一个线程进行访问,而读写锁在同一时 刻可以允许多个读线程访问,但是在写线程访问时,所有的读线程和其他写线程均被阻塞.读写锁维护了一对锁,一个读锁和一个写锁,通过分离读锁和写锁,使得 并发性相比一般的排他锁有了很大提升. 除了保证写操作对读操作的可见性以及并发性的提升之外,读写锁能够简化读写交互场景的编程方式.假设在程序中定义一个共享的数据结构用作缓存,它大部分时间提供读服务(例如:查

《Java并发编程的艺术》-Java并发包中的读写锁及其实现分析

作者:魏鹏  本文是<Java并发编程的艺术>的样章 1. 前言 在Java并发包中常用的锁(如:ReentrantLock),基本上都是排他锁,这些锁在同一时刻只允许一个线程进行访问,而读写锁在同一时刻可以允许多个读线程访问,但是在写线程访问时,所有的读线程和其他写线程均被阻塞.读写锁维护了一对锁,一个读锁和一个写锁,通过分离读锁和写锁,使得并发性相比一般的排他锁有了很大提升. 除了保证写操作对读操作的可见性以及并发性的提升之外,读写锁能够简化读写交互场景的编程方式.假设在程序中定义一个共享

Java垃圾回收机制中对象引用遍历的实现原理

问题描述 有没有大牛给详细解释下Java垃圾回收机制中对象引用遍历的实现原理,java回收机制中的有向图是何时建立.如何建立,有向图有几个? 解决方案 解决方案二:垃圾回收在jvm中并没有特定的算法,不同的人可以有不同的实现,未必会使用有向图譬如一种实现可以这样,在没有内存可分配时,直接抛出OutOfMemory都是符合规范的解决方案三:该回复于2011-04-07 11:01:48被版主删除解决方案四:这个要讲的话就多了解决方案五:有本书好像叫深入JVM,你可以找一下,里面解释的很详细解决方案

Java中的读/写锁

原文链接 作者:Jakob Jenkov 译者:微凉 校对:丁一 相比Java中的锁(Locks in Java)里Lock实现,读写锁更复杂一些.假设你的程序中涉及到对一些共享资源的读和写操作,且写操作没有读操作那么频繁.在没有写操作的时候,两个线程同时读一个资源没有任何问题,所以应该允许多个线程能在同时读取共享资源.但是如果有一个线程想去写这些共享资源,就不应该再有其它线程对该资源进行读或写(译者注:也就是说:读-读能共存,读-写不能共存,写-写不能共存).这就需要一个读/写锁来解决这个问题

ReentrantReadWriteLock读写锁的使用

Lock比传统线程模型中的synchronized方式更加面向对象,与生活中的锁类似,锁本身也应该是一个对象.两个线程执行的代码片段要实现同步互斥的效果,它们必须用同一个Lock对象. 读写锁:分为读锁和写锁,多个读锁不互斥,读锁与写锁互斥,这是由jvm自己控制的,你只要上好相应的锁即可.如果你的代码只读数据,可以很多 人同时读,但不能同时写,那就上读锁:如果你的代码修改数据,只能有一个人在写,且不能同时读取,那就上写锁.总之,读的时候上读锁,写的时候上写锁! ReentrantReadWrit

Java多线程同步设计中使用Metux

Mutex是互斥体,广泛地应用在多线程编程中.本文以广为流程的Doug Lea的concurrent工具包的Mutex实现为例,进行一点探讨.在Doug Lea的concurrent工具包中,Mutex实现了Sync接口,该接口是concurrent工具包中所有锁(lock).门(gate)和条件变量(condition)的公共接口,Sync的实现类主要有:Mutex.Semaphore及其子类.Latch.CountDown.ReentrantLock等.这也体现了面向抽象编程的思想,使我们可

Java多线程编程中线程锁与读写锁的使用示例_java

线程锁LockLock  相当于 当前对象的 Synchronized import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /* * Lock lock = new ReentrantLock(); * lock.lock(); lock.unLock(); * 类似于 synchronized,但不能与synchronized 混用 */ public class Lo

java多线程:jdk并发包的总结(转载)

转载地址:http://blog.csdn.net/yangbutao/article/details/8479520 1.java 高并发包所采用的几个机制(CAS,volatile,抽象队列同步)    CAS(乐观操作),jdk5以前采用synchronized,对共享区域进行同步操作,synchronized是重的操作,在高并发情况下,会引起线程频繁切换:而CAS是一种乐观锁机制,compare and swap,不加锁,而是假设没有冲突去完成,若有冲突会重试(非阻塞).compare&