ReentrantLock(重入锁)以及公平性

最新推荐文章于 2023-03-08 10:47:00 发布
最新推荐文章于 2023-03-08 10:47:00 发布
阅读量841 收藏
点赞数
分类专栏： Java实用 Java 基础 并发 文章标签： ReentrantLock
Java 基础 同时被 3 个专栏收录
37 篇文章 0 订阅
订阅专栏
Java实用
12 篇文章 0 订阅
订阅专栏
并发
3 篇文章 0 订阅
订阅专栏

简介

ReentrantLock的实现不仅可以替代隐式的synchronized关键字，而且能够提供超过关键字本身的多种功能。
这里提到一个锁获取的公平性问题，如果在绝对时间上，先对锁进行获取的请求一定被先满足，那么这个锁是公平的，反之，是不公平的，也就是说等待时间最长的线程最有机会获取锁，也可以说锁的获取是有序的。ReentrantLock这个锁提供了一个构造函数，能够控制这个锁是否是公平的。
而锁的名字也是说明了这个锁具备了重复进入的可能，也就是说能够让当前线程多次的进行对锁的获取操作，这样的最大次数限制是Integer.MAX_VALUE，约21亿次左右。
事实上公平的锁机制往往没有非公平的效率高，因为公平的获取锁没有考虑到操作系统对线程的调度因素，这样造成JVM对于等待中的线程调度次序和操作系统对线程的调度之间的不匹配。对于锁的快速且重复的获取过程中，连续获取的概率是非常高的，而公平锁会压制这种情况，虽然公平性得以保障，但是响应比却下降了，但是并不是任何场景都是以TPS作为唯一指标的，因为公平锁能够减少“饥饿”发生的概率，等待越久的请求越是能够得到优先满足。

实现分析

在ReentrantLock中，对于公平和非公平的定义是通过对同步器AbstractQueuedSynchronizer的扩展加以实现的，也就是在tryAcquire的实现上做了语义的控制。

非公平的获取语义：

01 final boolean nonfairTryAcquire(int acquires) {
02     final Thread current = Thread.currentThread();
03     int c = getState();
04     if (c == 0) {
05         if (compareAndSetState(0, acquires)) {
06             setExclusiveOwnerThread(current);
07             return true;
08         }
09     } else if (current == getExclusiveOwnerThread()) {
10         int nextc = c + acquires;
11                 if (nextc < 0) // overflow
12             throw new Error("Maximum lock count exceeded");
13         setState(nextc);
14         return true;
15     }
16     return false;
17 }

上述逻辑主要包括：

  • 如果当前状态为初始状态，那么尝试设置状态；
  • 如果状态设置成功后就返回；
  • 如果状态被设置，且获取锁的线程又是当前线程的时候，进行状态的自增；
  • 如果未设置成功状态且当前线程不是获取锁的线程，那么返回失败。

公平的获取语义：

01 protected final boolean tryAcquire(int acquires) {
02     final Thread current = Thread.currentThread();
03     int c = getState();
04     if (c == 0) {
05         if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) {
06             setExclusiveOwnerThread(current);
07             return true;
08         }
09     } else if (current == getExclusiveOwnerThread()) {
10         int nextc = c + acquires;
11         if (nextc < 0)
12             throw new Error("Maximum lock count exceeded");
13         setState(nextc);
14         return true;
15     }
16     return false;
17 }

上述逻辑相比较非公平的获取，仅加入了当前线程（Node）之前是否有前置节点在等待的判断。hasQueuedPredecessors()方法命名有些歧义，其实应该是currentThreadHasQueuedPredecessors()更为妥帖一些，也就是说当前面没有人排在该节点（Node）前面时候队且能够设置成功状态，才能够获取锁。

释放语义：

01 protected final boolean tryRelease(int releases) {
02     int c = getState() - releases;
03     if (Thread.currentThread() != getExclusiveOwnerThread())
04         throw new IllegalMonitorStateException();
05     boolean free = false;
06     if (c == 0) {
07         free = true;
08         setExclusiveOwnerThread(null);
09     }
10     setState(c);
11     return free;
12 }

上述逻辑主要主要计算了释放状态后的值，如果为0则完全释放，返回true，反之仅是设置状态，返回false。
下面将主要的笔墨放在公平性和非公平性上，首先看一下二者测试的对比：
测试用例如下：

01 public class ReentrantLockTest {
02     private static Lock fairLock = new ReentrantLock(true);
03     private static Lock unfairLock = new ReentrantLock();
04  
05     @Test
06     public void fair() {
07         System.out.println("fair version");
08         for (int i = 0; i < 5; i++) {
09             Thread thread = new Thread(new Job(fairLock));
10             thread.setName("" + i);
11             thread.start();
12         }
13  
14         try {
15             Thread.sleep(5000);
16         } catch (InterruptedException e) {
17             e.printStackTrace();
18         }
19     }
20  
21     @Test
22     public void unfair() {
23         System.out.println("unfair version");
24         for (int i = 0; i < 5; i++) {
25             Thread thread = new Thread(new Job(unfairLock));
26             thread.setName("" + i);
27             thread.start();
28         }
29  
30         try {
31             Thread.sleep(5000);
32         } catch (InterruptedException e) {
33             e.printStackTrace();
34         }
35     }
36  
37     private static class Job implements Runnable {
38         private Lock lock;
39         public Job(Lock lock) {
40             this.lock = lock;
41         }
42  
43         @Override
44         public void run() {
45             for (int i = 0; i < 5; i++) {
46                 lock.lock();
47                 try {
48                     System.out.println("Lock by:"
49                             + Thread.currentThread().getName());
50                 } finally {
51                     lock.unlock();
52                 }
53             }
54         }
55     }
56 }

调用非公平的测试方法，返回结果(部分)：
unfair version
Lock by:0
Lock by:0
Lock by:2
Lock by:2
Lock by:2
Lock by:2
Lock by:2
Lock by:0
Lock by:0
Lock by:0
Lock by:1
Lock by:1
Lock by:1
调用公平的测试方法，返回结果：
fair version
Lock by:0
Lock by:1
Lock by:0
Lock by:2
Lock by:3
Lock by:4
Lock by:1
Lock by:0
Lock by:2
Lock by:3
Lock by:4
仔细观察返回的结果(其中每个数字代表一个线程)，非公平的结果一个线程连续获取锁的情况非常多，而公平的结果连续获取的情况基本没有。那么在一个线程获取了锁的那一刻，究竟锁的公平性会导致锁有什么样的处理逻辑呢？
通过之前的同步器(AbstractQueuedSynchronizer)的介绍，在锁上是存在一个等待队列，sync队列，我们通过复写ReentrantLock的获取当前锁的sync队列，输出在ReentrantLock被获取时刻，当前的sync队列的状态。
修改测试如下：

01 public class ReentrantLockTest {
02     private static Lock fairLock = new ReentrantLock2(true);
03     private static Lock unfairLock = new ReentrantLock2();
04     @Test
05     public void fair() {
06         System.out.println("fair version");
07         for (int i = 0; i < 5; i++) {
08             Thread thread = new Thread(new Job(fairLock)) {
09                 public String toString() {
10                     return getName();
11                 }
12             };
13             thread.setName("" + i);
14             thread.start();
15         }
16         // sleep 5000ms
17     }
18  
19     @Test
20     public void unfair() {
21         System.out.println("unfair version");
22         for (int i = 0; i < 5; i++) {
23             Thread thread = new Thread(new Job(unfairLock)) {
24                 public String toString() {
25                     return getName();
26                 }
27             };
28             thread.setName("" + i);
29             thread.start();
30         }
31         // sleep 5000ms
32     }
33  
34     private static class Job implements Runnable {
35         private Lock lock;
36  
37         public Job(Lock lock) {
38             this.lock = lock;
39         }
40  
41         @Override
42         public void run() {
43             for (int i = 0; i < 5; i++) {
44                 lock.lock();
45                 try {
46                     System.out.println("Lock by:"
47                             + Thread.currentThread().getName() + " and "
48                             + ((ReentrantLock2) lock).getQueuedThreads()
49                             + " waits.");
50                 } finally {
51                     lock.unlock();
52                 }
53             }
54         }
55     }
56  
57     private static class ReentrantLock2 extends ReentrantLock {
58         // Constructor Override
59  
60         private static final long serialVersionUID = 1773716895097002072L;
61  
62         public Collection<Thread> getQueuedThreads() {
63             return super.getQueuedThreads();
64         }
65     }
66 }

上述逻辑主要是通过构造ReentrantLock2用来输出在sync队列中的线程内容，而且每个线程的toString方法被重写，这样当一个线程获取到锁时，sync队列里的内容也就可以得知了，运行结果如下：
调用非公平方法，返回结果：
unfair version
Lock by:0 and [] waits.
Lock by:0 and [] waits.
Lock by:3 and [2, 1] waits.
Lock by:3 and [4, 2, 1] waits.
Lock by:3 and [4, 2, 1] waits.
Lock by:3 and [0, 4, 2, 1] waits.
Lock by:3 and [0, 4, 2, 1] waits.
Lock by:1 and [0, 4, 2] waits.
Lock by:1 and [0, 4, 2] waits.
调用公平方法，返回结果：
fair version
Lock by:0 and [] waits.
Lock by:1 and [0, 4, 3, 2] waits.
Lock by:2 and [1, 0, 4, 3] waits.
Lock by:3 and [2, 1, 0, 4] waits.
Lock by:4 and [3, 2, 1, 0] waits.
Lock by:0 and [4, 3, 2, 1] waits.
Lock by:1 and [0, 4, 3, 2] waits.
Lock by:2 and [1, 0, 4, 3] waits.
可以明显看出，在非公平获取的过程中，“插队”现象非常严重，后续获取锁的线程根本不顾及sync队列中等待的线程，而是能获取就获取。反观公平获取的过程，锁的获取就类似线性化的，每次都由sync队列中等待最长的线程（链表的第一个，sync队列是由尾部结点添加，当前输出的sync队列是逆序输出）获取锁。一个 hasQueuedPredecessors方法能够获得公平性的特性，这点实际上是由AbstractQueuedSynchronizer来完成的，看一下acquire方法：

1 public final void acquire(int arg) {
2     if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
3         selfInterrupt();
4 }

可以看到，如果获取状态和在sync队列中排队是短路的判断，也就是说如果tryAcquire成功，那么是不会进入sync队列的，可以通过下图来深刻的认识公平性和AbstractQueuedSynchronizer的获取过程。
非公平的，或者说默认的获取方式如下图所示：

对于状态的获取，可以快速的通过tryAcquire的成功，也就是黄色的Fast路线，也可以由于tryAcquire的失败，构造节点，进入sync队列中排序后再次获取。因此可以理解为Fast就是一个快速通道，当例子中的线程释放锁之后，快速的通过Fast通道再次获取锁，就算当前sync队列中有排队等待的线程也会被忽略。这种模式，可以保证进入和退出锁的吞吐量，但是sync队列中过早排队的线程会一直处于阻塞状态，造成“饥饿”场景。
而公平性锁，就是在tryAcquire的调用中顾及当前sync队列中的等待节点（废弃了Fast通道），也就是任意请求都需要按照sync队列中既有的顺序进行，先到先得。这样很好的确保了公平性，但是可以从结果中看到，吞吐量就没有非公平的锁高了。

原创文章，转载请注明： 转载自并发编程网 – ifeve.com本文链接地址: ReentrantLock(重入锁)以及公平性

孤天浪雨
关注
专栏目录
JAVA可重入锁ReentrantLock及其公平性
romantic_jie的博客
09-02 313
重入锁ReentrantLock 顾名思义，就是支持重复进入的锁，它表示该所能够支持一个线程对资源的重复加锁。而除此之外，该所还支持了获取锁时的公平和非公平性的选择。注意，ReentrantLock是一个独占锁。 重入性分析及实现 分析 这里对比一下synchronized：要知道，synchronized也是支持可重入的，只不过是隐式的，例如，一个synchronized关键字修饰的递归...
可重入锁
JOHNKING123的专栏
11-25 7990
原文：https://www.shiyanlou.com/questions/2460 1 . 什么是可重入锁 锁的概念就不用多解释了,当某个线程A已经持有了一个锁,当线程B尝试进入被这个锁保护的代码段的时候.就会被阻塞.而锁的操作粒度是”线程”,而不是调用(至于为什么要这样,下面解释).同一个线程再次进入同步代码的时候.可以使用自己已经获取到的锁,这就是可重入锁java里面内置锁(s
ReentrantLock的公平锁和非公平锁
wj11825的博客
09-25 288
今天学习了一下关于Lock中的公平锁和非公平锁，就想总结一下这两种之间的区别。具体有不对的地方欢迎指正。     首先锁Lock分为"公平锁"和"非公平锁"，公平锁表示线程获取锁的顺序是按照线程加锁的顺序来分配的，即呢就是先来先得的FIFO先进先顺序。非公平锁就是获取锁的抢占机制，是随机获取锁的，那这俩货的区别就在这个地方了，非公平锁先来的不一定先得到锁，这就会造成某些线程可能一直拿不到锁，结果
教你完全理解ReentrantLock重入锁
10-16
总结来说，理解ReentrantLock的关键在于掌握其重入性、公平性和非公平性，以及如何通过构造函数选择锁类型。同时，要了解其内部是如何通过AQS（AbstractQueuedSynchronizer）来管理锁的状态和线程等待队列，以及如何...
ReentrantLock源码详解--公平锁、非公平锁
08-25
ReentrantLock的可重入性是指一个线程获取锁之后再尝试获取锁时会自动获取锁。ReentrantLock的可重入性是通过继承AQS实现的。ReentrantLock的可重入性使得其可以在实际编程中使用频率很高。 ReentrantLock是一种...
Java源码解析之可重入锁ReentrantLock
08-26
Java源码解析之可重入锁ReentrantLock ReentrantLock是一个可重入锁，在ConcurrentHashMap中使用了ReentrantLock。它是一个可重入的排他锁，它和synchronized的方法和代码有着相同的行为和语义，但有更多的功能。 ...
ReentrantLock可重入锁、公平锁、非公平锁源码分析
跟心爱的人一起浪迹天涯
11-17 161
ReentrantLock 可重入锁，实现了公平锁和非公平锁两种机制，主要区别就是非公平锁会先获取锁，如果成功，会插队执行，而非公平锁会直接进入队列，依次执行。非公平锁并发量大，性能高，但是有可能出现线程饥饿现象。 ReentrantLock 底层使用AQS独占锁为基础实现同步机制，重写了tryAcquire和tryRelease方法，分别用来获取锁和释放锁。可重入是通过exclusiveOwnerThread和state值来控制的，获取锁时判断是否是持有锁线程，如果是，获取成功，否则入队列。 源码 pub
ReentranLock（可重入锁）
最新发布
m0_56188609的博客
03-08 1098
条件变量synchronized 中也有条件变量，就是我们讲原理时那个 waitSet 休息室，当条件不满足时进入 waitSet 等待ReentrantLock 的条件变量比 synchronized 强大之处在于，它是支持多个条件变量的，这就好比● synchronized 是那些不满足条件的线程都在一间休息室等消息● 而 ReentrantLock 支持多间休息室，有专门等烟的休息室、专门等早餐的休息室、唤醒时也是按休息室来唤醒使用要点：● await 前需要获得锁。
ReentrantLock 可重入锁
ProMonkey_chen的博客
12-16 205
可重入性是指线程在持有锁的情况下再次请求加锁，如果一个锁支持同一个线程的多次加锁，那么这个锁就是可重入的。比如 Java 语言里有个 ReentrantLock 就是可重入锁。如果Redis 分布式锁要支持可重入，需要对客户端的 set 方法进行包装，使用线程的 Threadlocal 变量存储当前持有锁的计数。 代码如下： public class RedisWithRee...
ReentrantLock — 可重入锁
leimeng123的博客
10-27 1442
J.U.C Java.util.concurrent（java并发应用包） 是在并发编程中比较常用的工具类，里面包含很多用来在并发场景中使用的组件。比如线程池、阻塞队列、计时器、同步器、并发集合等等。并发包的作者是大名鼎鼎的 Doug Lea。 ReentrantLock Lock在J.U.C中是最核心的组件，J.U.C 包中的所有组件绝大部分的组件都有用到了 Lock。在 Lock 接口出现之前，Java中的应用程序对于多线程的并发安全处理只能基于synchronized关键字来解决。Reentra
可重入锁ReentrantLock
Q酱的专栏
11-26 137
参考：https://blog.csdn.net/qq_38293564/article/details/80515718 https://segmentfault.com/a/1190000014419022?utm_source=index-hottest 1.ReentrantLock分为公平锁和非公平锁，默认是不公平锁。（为什么默认是不公平锁呢？因为不公平锁线程切换少，吞吐率会更高，但...
图解 ReentrantLock 公平锁和非公平锁实现
Q54665642ljf的博客
10-17 525
ReentrantLock 是 Java 并发中十分常用的一个类，具备类似 synchronized 锁的作用。但是相比 synchronized, 它具备更强的能力，同时支持公平锁和非公平锁。指多个线程按照申请锁的顺序来获取锁，线程直接进入队列中排队，队列中的第一个线程才能获得锁。多个线程加锁时直接尝试获取锁，能抢到锁到直接占有锁，抢不到才会到等待队列的队尾等待。那 ReentrantLock 中具体是怎么实现公平和非公锁的呢？它们之间又有什么优缺点呢？本文就带大家一探究竟。
可重入独占锁ReentrantLock
CodePanda@GPF的博客
04-02 1347
ReentrantLock锁原理、可重入锁、独占锁
Java并发编程-ReentrantLock可重入锁
Java硬件工程师的博客
02-05 1785
目录1.ReentrantLock可重入锁概述2.可重入3.可打断4.锁超时5.公平锁6.条件变量 Condition 1.ReentrantLock可重入锁概述 相对于 synchronized 它具备如下特点 可中断 synchronized锁加上去不能中断，a线程应用锁，b线程不能取消掉它 可以设置超时时间 synchronized它去获取锁时，如果对方持有锁，那么它就会进入entryList一直等待下去。而可重入锁可以设置超时时间，规定时间内如果获取不到锁，就放弃锁 可以设置为公平锁 防止线程饥饿的
ReentrantLock-可重入锁
tanglihai的博客
02-16 359
1.下面先分析一下ReentrantLock类 private final Sync sync; ReentrantLock持有了sync变量，Sync类下面有FairSync和NonfairSync，也就是通常所说的公平锁和非公平锁。 2.构造方法 public ReentrantLock() { sync = new NonfairSync(); } public ReentrantLock(boolean fair) { syn
java中的可重入锁ReentrantLock
FlowingRiver
03-04 1087
翻译自geeksforgeeks。 背景 在Java中实现线程同步的传统方法是使用synchronized关键字。 虽然它提供了基本同步功能，但synchronized的使用比较死板。 比如说，一个线程只能锁一次。同步块不提供任何等待队列的机制，并且在一个线程退出后，任何线程都可以获取锁。这可能导致很长一段时间内某些其他线程的资源匮乏。 Java中提供了可重入锁(ReentrantLock)，以提...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值