# Java读写锁默认是公平锁的实现
## 1. 介绍
在Java中,读写锁是一种特殊的锁机制,用于解决多线程读写操作的并发性问题。读写锁由读锁和写锁组成,多个线程可以同时获取读锁,但只有一个线程可以获取写锁。
在默认情况下,Java的读写锁实现是公平锁。公平锁是指多个线程请求锁时,锁的获取顺序与线程请求锁的顺序一致。这意味着先请求锁的线程会先获取到锁,后请求锁的线程会排队等待获取锁。
本            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2023-12-11 14:55:25
                            
                                25阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            在上文中提到了Lock接口以及对象,使用它,很优雅的控制了竞争资源的安全访问,但是这种锁不区分读写,称这种锁为普通锁。为了提高性能,Java提供了读写锁,在读的地方使用读锁,在写的地方使用写锁,灵活控制, 
  如果没有写锁的情况下,读是无阻塞的,在一定程度上提高了程序的执行效率。 
     
   Java中读写锁有个接口java.util.concurrent.locks.ReadW            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-09-13 23:25:58
                            
                                37阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            各种锁 可重入锁、公平锁\非公平锁、独占锁\共享锁、读写锁
锁状态 重量级锁、轻量级锁、偏量锁、锁膨胀、锁粗化、锁自旋\自定义自旋
volatile轻量级锁,锁变量,可见性
synchronized使用方式,不同使用方式的底层实现,非公平锁,锁升级原理,锁优化,降级
单例模式与synchronized和volatile
CAS 原理   解决ABA问题
Atom            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-11-28 10:23:33
                            
                                135阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            锁理论
    一、概述1. Java读写锁理论锁的种类:(1) 独享/共享锁  (广义)独占锁:是指该锁一次只能被一个线程锁持有,eg:ReentrantLock、Sychronized;共享锁:是指该锁可被多个线程持有,eg: ReentrantReadWriteLock,其读锁是共享锁,其写锁是独占锁;(2) 互斥/读写锁  (具体)互            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-01-12 01:13:01
                            
                                61阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            读写锁1、概念2、代码3、锁降级 1、概念JAVA 的并发包提供了读写锁 ReentrantReadWriteLock 它表示两个锁,一个是读操作相关的锁,称为共享锁;一个是写相关的锁,称为排他锁读锁:针对同一份数据,多个读操作可以同时进行而不会互相影响。 写锁:当前操作没有完成之前,它会阻断其他写锁和读锁。线程进入读锁的前提条件: 
  没有其他线程的写锁没有写请求, 或者有写请求,但调用线程            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-08-11 09:18:51
                            
                                69阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            Java语言中有许多原生线程安全的数据结构,比如ArrayBlockingQueue、CopyOnWriteArrayList、LinkedBlockingQueue,它们线程安全的实现方式并非通过synchronized关键字,而是通过java.util.concurrent.locks.ReentrantLock来实现。            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-06-15 08:56:17
                            
                                123阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            使用公平锁的原因是为了防止饥饿,导致饥饿的原因如下: 
1、高优先级线程吞噬所有的低优先级线程的CPU时间(高优先级任务会获取更多的时间片)。            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-06-15 09:11:25
                            
                                157阅读
                            
                                                                             
                 
                
                             
         
            
            
            
                         
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2021-12-30 11:22:06
                            
                                734阅读
                            
                                                                             
                 
                
                             
         
            
            
            
                    从公平的角度来说,Java 中的锁总共可分为两类:公平锁和非公平锁。但公平锁和非公平锁有哪些区别?正文公平锁:每个线程获取锁的顺序是按照线程访问锁的先后顺序获取的,最前面的线程总是最先获取到锁。非公平锁:每个线程获取锁的顺序是随机的,并不会遵循先来先得的规则,所有线程会竞争获取锁。举个例子,公平锁就像开车经过收费站一样,所有的车都会排队等待通            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-18 23:11:00
                            
                                730阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            从公平的角度来说,Java 中的锁总共可分为两类:公平锁和非公平锁。但公平锁和非公平锁有哪些区别?孰优孰劣呢?在 Java 中的应用场景又有哪些呢?接下来我们一起来看。正文公平锁:每个线程获取锁的顺序是按照线程访问锁的先后顺序获取的,最前面的线程总是最先获取到锁。非公平锁:每个线程获取锁的顺序是随机的,并不会遵循先来先得的规则,所有线程会竞争获取锁。举个例子,公平锁就像开车经过收费站一样,所有的车            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-11-08 20:41:01
                            
                                74阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            # 理解 Java 中的 ReentrantLock 公平锁
在多线程编程中,对共享资源的访问控制是非常重要的。Java 提供了 `java.util.concurrent.locks.ReentrantLock` 类用来处理并发问题,其中可以创建公平锁和非公平锁。在这篇文章中,我们将深入了解如何实现一个默认的公平锁,并通过流程图和序列图来帮助理解整个过程。
## 1. 整体流程
首先,我们            
                
         
            
            
            
            Java中的公平锁和非公平锁实现详解 在Java中实现锁的方式有两种,一种是使用Java自带的关键字synchronized对相应的类或者方法以及代码块进行加锁,另一种是ReentrantLock,前者只能是非公平锁,而后者是默认非公平但可实现公平的一把锁。ReentrantLock的实现是基于其内部类FairSync(公平锁)和NonFairSync(非公平锁)实现的。 其可重入性是基            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-07-26 14:31:50
                            
                                125阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            锁锁实现的模型有CAS和AQS公平锁ReentrantLock的底层实现为AbstractQueuedSynchronizer,其中的同步器有NonfairSync和FairSync两种public ReentrantLock(boolean fair) {
	sync = fair ? new FairSync() : new NonfairSync(); 3	}
public Reentran            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-06-24 08:02:46
                            
                                63阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            # Java中的公平锁和非公平锁
在Java中,锁是实现多线程同步的重要机制。Java提供了两种类型的锁:公平锁和非公平锁。这两种锁的区别在于线程获取锁的顺序。
## 公平锁
公平锁是指线程获取锁的顺序按照线程加锁的顺序来进行。当一个线程尝试获取一个公平锁时,如果锁已经被其他线程占用,则该线程会被放入等待队列中,等待其他线程释放锁后按照先来后到的顺序获取锁。
在Java中,Reentran            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2024-04-07 05:28:20
                            
                                384阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            公平锁和非公平锁区别公平锁:大家老老实实排队,先来后到,等待队列按照FIFO规则获取锁。非公平锁:抢占资源,多线程获取锁的顺序不按照申请锁的顺序;在高并发情况下,有可能会造成优先级反转或饥饿现象;优点在于性能比公平锁大。如何得到公平/非公平锁?并发包中ReentrantLock的创建可以指定构造函数的boolean类型来得到公平/非公平锁,默认是非公平锁。ReentrantLock默认是非公平锁;            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-06-25 20:42:52
                            
                                452阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            接着上篇未讲完的部分,咱们继续来聊聊锁这个话题。 
 重入锁(ReentrantLock)Java SE5以后,Java并发包基于Lock接口,实现了高性能的支持重入的锁ReentrantLock。重入这里指的是在某线程已经获取锁之后,该线程可以再次获取锁,进入同步代码块。这里需要强调一下重入的概念中所指的线程是已经获得锁的的线程,这与线程安全不冲突,因为只有一个线程可以获取            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2024-04-12 04:59:40
                            
                                73阅读
                            
                                                                             
                 
                
                                
                     
                                    
                             
         
            
            
            
            总结 1-悲观锁:Java里使用的各种锁:互斥锁、自旋锁、读写锁,都是属于悲观锁。悲观锁做事比较悲观,它认为多线程同时修改共享资源的概率比较高,于是很容易出现冲突,所以访问共享资源前,先要上锁。 2-乐观锁:Java里很少有乐观锁。目前据我所知,java.util.concurrent.atomic            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2020-09-19 19:49:00
                            
                                185阅读
                            
                                                                                    
                                2评论
                            
                                                 
                 
                
                             
         
            
            
            
            一、锁的公平性含义所谓公平锁,就是在绝对时间上,先对锁发起获取请求的一定先被满足,那么这个锁是公平的,反之,则是非公平的。因为ReentrantLock的实现是通过自定义的静态内部类sync实现的,sync继承了AbstractQueuedSynchronizor抽象类,因此ReentrantLock也是实现了基于双向链表的同步队列,也就是说,如果每次都是选择队列头的Node关联的线程获取锁,那就            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2023-08-24 09:38:31
                            
                                49阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            可重入锁指的是在同一个thread中,获取锁之后再次使用同样的方法或对象中的其他方法可以直接操作,而不需要重新获取锁。它是基于thread粒度的,per-thread。不可重入锁指的是每次使用锁方法时,都需要重新获取锁,即使在同一线程中调用同一方法都需要等待上一个锁的释放。它是基于method粒度的,per-invocation。可重入锁与不可重复锁的例子//设计一个锁publicclassLoc            
                
                    
                        
                                                            
                                                                        
                                                                                        原创
                                                                                    
                            2018-06-25 14:47:31
                            
                                4542阅读
                            
                                                                             
                 
                
                             
         
            
            
            
            如果需要查看具体的synchronized和lock的实现原理,请参考:解决多线程安全问题-无非两个方法synchronized和lock 具体原理(百度) 在并发编程中,经常遇到多个线程访问同一个 共享资源 ,这时候作为开发者必须考虑如何维护数据一致性,在java中synchronized关键字被            
                
                    
                        
                                                            
                                                                        
                                                                                        转载
                                                                                    
                            2017-06-01 19:28:00
                            
                                202阅读
                            
                                                                                    
                                2评论