目录 1.ReentrantLock可重入锁概述2.可重入3.可打断4.锁超时5.公平锁6.条件变量 Condition
1.ReentrantLock可重入锁概述
相对于 synchronized 它具备如下特点
可中断
synchronized锁加上去不能中断，a线程应用锁，b线程不能取消掉它
可以设置超时时间
synchronized它去获取锁时，如果对方持有锁，那么它就会进入entryList一直等待下去。而可重入锁可以设置超时时间，规定时间内如果获取不到锁，就放弃锁
可以设置为公平锁
防止线程饥饿的情况，即先到先得。如果争抢的人比较多，则可能会发生永远都得不到锁
支持多个条件变量多个waitset（不支持条件一的去a不支持条件二的去b）
synchronized只支持同一个waitset.
与 synchronized 一样，都支持可重入
基本语法
|
1
2
3
4
5
6
7
8
|
// 获取锁reentrantLock.lock();try { // 临界区} finally { // 释放锁 reentrantLock.unlock();} |
synchronized是在关键字的级别来保护临界区，而reentrantLock是在对象的级别保护临界区。临界区即访问共享资源的那段代码。finally中表明不管将来是否出现异常，都会释放锁，释放锁即调用unlock方法。否则无法释放锁，其它线程就永远也获取不了锁。
2.可重入
可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁
如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住
ReentrantLock和synchronized都是可重入锁。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
public class TestReentranLock1 { static ReentrantLock lock = new ReentrantLock(); public static void main(String[] args) { method1(); } public static void method1() { lock.lock(); try { System.out.println("execute method1"); method2(); } finally { lock.unlock(); } } public static void method2() { lock.lock(); try { System.out.println("execute method2"); method3(); } finally { lock.unlock(); } } public static void method3() { lock.lock(); try { System.out.println("execute method3"); } finally { lock.unlock(); } }} |
|
1
2
3
|
execute method1execute method2execute method3 |
3.可打断
可打断是指在等待锁的过程中，其它线程可以用interrupt方法终止我的等待。synchronized锁是不可打断的。
我们要想在等锁的过程中被打断，就要使用lockInterruptibly()方法对lock对象加锁，而不是lock()方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
|
public class TestReentranLock2 { public static void main(String[] args) { ReentrantLock lock = new ReentrantLock(); Thread t1 = new Thread(() -> { try { //如果没有竞争，此方法就会获取lock对象的锁 //如果有竞争，就进入阻塞队列等待，可以被其它线程用interrupt打断 System.out.println("尝试获得锁"); lock.lockInterruptibly(); } catch (InterruptedException e) { e.printStackTrace(); System.out.println("等锁的过程中被打断"); return; } try { System.out.println("t1获得了锁"); } finally { lock.unlock(); } }, "t1"); lock.lock(); System.out.println("主线程获得了锁"); t1.start(); try { try { sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } t1.interrupt(); System.out.println("执行打断t1"); } finally { lock.unlock(); } }} |
|
1
2
3
4
5
6
7
8
9
10
|
主线程获得了锁尝试获得锁执行打断t1等锁的过程中被打断java.lang.InterruptedException at java.util.concurrent.locks.AbstractQueuedSynchronizer.doAcquireInterruptibly(AbstractQueuedSynchronizer.java:898) at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireInterruptibly(AbstractQueuedSynchronizer.java:1222) at java.util.concurrent.locks.ReentrantLock.lockInterruptibly(ReentrantLock.java:335) at cn.yj.jvm.TestReentranLock2.lambda$main$0(TestReentranLock2.java:15) at java.lang.Thread.run(Thread.java:748) |
注意如果是不可中断模式，那么即使使用了 interrupt 也不会让等待中断，即不是。即使用lock()方法。
这种方式可以避免死锁情况的发生，避免无休止的等待。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
|
ReentrantLock lock = new ReentrantLock();Thread t1 = new Thread(() -> { System.out.println("启动..."); lock.lock(); try { System.out.println("获得了锁"); } finally { lock.unlock(); }}, "t1");lock.lock();System.out.println("获得了锁");t1.start();try { sleep(1); t1.interrupt(); System.out.println("执行打断"); sleep(1);} finally { System.out.println("释放了锁"); lock.unlock();} |
4.锁超时
ReentranLock支持可打断，其实就是为了避免死等，这样就可以减少死锁的发生。实际上可打断这种方式属于一种被动的避免死等，是由其它线程interrupt来打断。
而锁超时是主动的方式避免死等的手段。
获取锁用tryLock()方法，即尝试获得锁，如果成功了，它就获得锁，如果失败了，它就可以不去进入阻塞队列等待，它就会返回false，表示没有获得锁。
立刻失败
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
public static void main(String[] args) { ReentrantLock lock = new ReentrantLock(); Thread t1 = new Thread(() -> { System.out.println("启动..."); if (!lock.tryLock()) { System.out.println("获取不到锁，立刻失败，返回"); return; } try { System.out.println("获得了锁"); } finally { lock.unlock(); } }, "t1"); lock.lock(); System.out.println("获得了锁"); t1.start(); try { try { sleep(500); } catch (InterruptedException e) { e.printStackTrace(); } } finally { lock.unlock(); }} |
获得了锁
启动...
获取不到锁，立刻失败，返回
超时失败
lock.tryLock(1,TimeUnit.SECONDS)表示尝试等待1s，如果主线程不释放锁，那么它就会返回false，如果释放了锁，那么它就会返回true.tryLock也支持被打断，被打断时报异常。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
ReentrantLock lock = new ReentrantLock();Thread t1 = new Thread(() -> { log.debug("启动..."); try { if (!lock.tryLock(1, TimeUnit.SECONDS)) { log.debug("获取等待 1s 后失败，返回"); return; } } catch (InterruptedException e) { e.printStackTrace(); } try { log.debug("获得了锁"); } finally { lock.unlock(); }}, "t1");lock.lock();log.debug("获得了锁");t1.start();try { sleep(2);} finally { lock.unlock();} |
输出
18:19:40.537 [main] c.TestTimeout - 获得了锁
18:19:40.544 [t1] c.TestTimeout - 启动...
18:19:41.547 [t1] c.TestTimeout - 获取等待 1s 后失败，返回
5.公平锁
对于synchronized来说，它是不公平的锁。当一个线程持有锁，其他线程就会进入阻塞队列等待，当锁的持有者释放锁的时候，这些线程就会一拥而上，谁先抢到，谁就成为monitor的主人，而不会按照先来先得的规则。
ReentrantLock 默认是不公平的
ReentrantLock有一个带参构造方法。默认是非公平的。
|
1
2
3
|
public ReentrantLock(boolean fair) { sync = fair ? new FairSync() : new NonfairSync();} |
我们可以通过布尔值改成真，来保证它的公平性。即将来阻塞队列里的线程，争抢锁的时候会按照进入阻塞队列的顺序执行，先到先得。
6.条件变量 Condition
synchronized 中也有条件变量，就是我们讲原理时那个 waitSet 休息室，当条件不满足时进入 waitSet 等待
ReentrantLock 的条件变量比 synchronized 强大之处在于，它是支持多个条件变量的，这就好比
synchronized 是那些不满足条件的线程都在一间休息室等消息
而 ReentrantLock 支持多间休息室，有专门等烟的休息室、专门等早餐的休息室、唤醒时也是按休息室来唤醒
使用要点：
- await 前需要获得锁
- await 执行后，会释放锁，进入 conditionObject 等待
- await 的线程被唤醒（或打断、或超时）取重新竞争 lock 锁
- 竞争 lock 锁成功后，从 await 后继续执行
- signal 相当于 notify，signalAll 相当于 notifyAll
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
|
static ReentrantLock lock = new ReentrantLock();static Condition waitCigaretteQueue = lock.newCondition();static Condition waitbreakfastQueue = lock.newCondition();static volatile boolean hasCigrette = false;static volatile boolean hasBreakfast = false;public static void main(String[] args) { new Thread(() -> { try { lock.lock(); while (!hasCigrette) { try { waitCigaretteQueue.await(); } catch (InterruptedException e) { e.printStackTrace(); } } log.debug("等到了它的烟"); } finally { lock.unlock(); } }).start(); new Thread(() -> { try { lock.lock(); while (!hasBreakfast) { try { waitbreakfastQueue.await(); } catch (InterruptedException e) { e.printStackTrace(); } } log.debug("等到了它的早餐"); } finally { lock.unlock(); } }).start(); sleep(1); sendBreakfast(); sleep(1); sendCigarette();}private static void sendCigarette() { lock.lock(); try { log.debug("送烟来了"); hasCigrette = true; waitCigaretteQueue.signal(); } finally { lock.unlock(); }}private static void sendBreakfast() { lock.lock(); try { log.debug("送早餐来了"); hasBreakfast = true; waitbreakfastQueue.signal(); } finally { lock.unlock(); }} |
输出
18:52:27.680 [main] c.TestCondition - 送早餐来了
18:52:27.682 [Thread-1] c.TestCondition - 等到了它的早餐
18:52:28.683 [main] c.TestCondition - 送烟来了
18:52:28.683 [Thread-0] c.TestCondition - 等到了它的烟
到此这篇关于Java并发编程之ReentrantLock可重入锁的实例代码的文章就介绍到这了,更多相关Java ReentrantLock可重入锁内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！
原文链接：https://blog.csdn.net/qq_39736597/article/details/113701074
