synchronized 的局限性
synchronized 是 java 内置的关键字，它提供了一种独占的加锁方式。synchronized 的获取和释放锁由 jvm 实现，用户不需要显示的释放锁，非常方便，然而 synchronized 也有一定的局限性，例如：
- 当线程尝试获取锁的时候，如果获取不到锁会一直阻塞，这个阻塞的过程，用户无法控制
- 如果获取锁的线程进入休眠或者阻塞，除非当前线程异常，否则其他线程尝试获取锁必须一直等待
JDK1.5 之后发布，加入了 Doug Lea 实现的 java.util.concurrent 包。包内提供了 Lock 类，用来提供更多扩展的加锁功能。Lock 弥补了 synchronized 的局限，提供了更加细粒度的加锁功能。
ReentrantLock
ReentrantLock 是 Lock 的默认实现，在聊 ReentranLock 之前，我们需要先弄清楚一些概念：
- 可重入锁：可重入锁是指同一个线程可以多次获得同一把锁；ReentrantLock 和关键字 Synchronized 都是可重入锁
- 可中断锁：可中断锁是子线程在获取锁的过程中，是否可以响应线程中断操作。synchronized 是不可中断的，ReentrantLock 是可中断的
- 公平锁和非公平锁：公平锁是指多个线程尝试获取同一把锁的时候，获取锁的顺序按照线程到达的先后顺序获取，而不是随机插队的方式获取。synchronized 是非公平锁，而 ReentrantLock 是两种都可以实现，不过默认是非公平锁
ReentrantLock 基本使用
我们使用 3 个线程来对一个共享变量++操作，先使用synchronized实现，然后使用ReentrantLock实现。
synchronized 方式：
package com.itsoku.chat06;
/
微信公众号：程序员路人，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo2** {
**private** **static** **int** num = 0;**private** **static** **synchronized** **void** **add**() {<br /> num++;<br /> }**public** **static** **class** **T** **extends** **Thread** {<br /> @Override<br /> **public** **void** **run**() {<br /> **for** (**int** i = 0; i < 10000; i++) {<br /> Demo2.add();<br /> }<br /> }<br /> }**public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br /> T t1 = **new** T();<br /> T t2 = **new** T();<br /> T t3 = **new** T();t1.start();<br /> t2.start();<br /> t3.start();t1.join();<br /> t2.join();<br /> t3.join();System.out.println(Demo2.num);<br /> }<br />}
ReentrantLock 方式：
package com.itsoku.chat06;
import java.util.concurrent.locks.ReentrantLock;
/
微信公众号：程序员路人，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo3** {
**private** **static** **int** num = 0;**private** **static** ReentrantLock lock = **new** ReentrantLock();**private** **static** **void** **add**() {<br /> lock.lock();<br /> **try** {<br /> num++;<br /> } **finally** {<br /> lock.unlock();<br /> }}**public** **static** **class** **T** **extends** **Thread** {<br /> @Override<br /> **public** **void** **run**() {<br /> **for** (**int** i = 0; i < 10000; i++) {<br /> Demo3.add();<br /> }<br /> }<br /> }**public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br /> T t1 = **new** T();<br /> T t2 = **new** T();<br /> T t3 = **new** T();t1.start();<br /> t2.start();<br /> t3.start();t1.join();<br /> t2.join();<br /> t3.join();System.out.println(Demo3.num);<br /> }<br />}
ReentrantLock 的使用过程：
- 创建锁：ReentrantLock lock = new ReentrantLock();
- 获取锁：lock.lock()
- 释放锁：lock.unlock();
对比上面的代码，与关键字 synchronized 相比，ReentrantLock 锁有明显的操作过程，开发人员必须手动的指定何时加锁，何时释放锁，正是因为这样手动控制，ReentrantLock 对逻辑控制的灵活度要远远胜于关键字 synchronized，上面代码需要注意lock.unlock()一定要放在 finally 中，否则，若程序出现了异常，锁没有释放，那么其他线程就再也没有机会获取这个锁了。
ReentrantLock 是可重入锁
来验证一下 ReentrantLock 是可重入锁，实例代码：
package com.itsoku.chat06;
import java.util.concurrent.locks.ReentrantLock;
/
微信公众号：程序员路人，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo4 {
private static int num = 0;
private static ReentrantLock lock = new** ReentrantLock();
**private** **static** **void** **add**() {<br /> lock.lock();<br /> lock.lock();<br /> **try** {<br /> num++;<br /> } **finally** {<br /> lock.unlock();<br /> lock.unlock();<br /> }<br /> }**public** **static** **class** **T** **extends** **Thread** {<br /> @Override<br /> **public** **void** **run**() {<br /> **for** (**int** i = 0; i < 10000; i++) {<br /> Demo4.add();<br /> }<br /> }<br /> }**public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br /> T t1 = **new** T();<br /> T t2 = **new** T();<br /> T t3 = **new** T();t1.start();<br /> t2.start();<br /> t3.start();t1.join();<br /> t2.join();<br /> t3.join();System.out.println(Demo4.num);<br /> }<br />}
上面代码中 add()方法中，当一个线程进入的时候，会执行 2 次获取锁的操作，运行程序可以正常结束，并输出和期望值一样的 30000，假如 ReentrantLock 是不可重入的锁，那么同一个线程第 2 次获取锁的时候由于前面的锁还未释放而导致死锁，程序是无法正常结束的。ReentrantLock 命名也挺好的 Re entrant Lock，和其名字一样，可重入锁。
代码中还有几点需要注意：
- lock()方法和 unlock()方法需要成对出现，锁了几次，也要释放几次，否则后面的线程无法获取锁了；可以将 add 中的 unlock 删除一个事实，上面代码运行将无法结束
- unlock()方法放在 finally 中执行，保证不管程序是否有异常，锁必定会释放
ReentrantLock 实现公平锁
在大多数情况下，锁的申请都是非公平的，也就是说，线程 1 首先请求锁 A，接着线程 2 也请求了锁 A。那么当锁 A 可用时，是线程 1 可获得锁还是线程 2 可获得锁呢？这是不一定的，系统只是会从这个锁的等待队列中随机挑选一个，因此不能保证其公平性。这就好比买票不排队，大家都围在售票窗口前，售票员忙的焦头烂额，也顾及不上谁先谁后，随便找个人出票就完事了，最终导致的结果是，有些人可能一直买不到票。而公平锁，则不是这样，它会按照到达的先后顺序获得资源。公平锁的一大特点是：它不会产生饥饿现象，只要你排队，最终还是可以等到资源的；synchronized 关键字默认是有 jvm 内部实现控制的，是非公平锁。而 ReentrantLock 运行开发者自己设置锁的公平性。
看一下 jdk 中 ReentrantLock 的源码，2 个构造方法：
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
默认构造方法创建的是非公平锁。
第 2 个构造方法，有个 fair 参数，当 fair 为 true 的时候创建的是公平锁，公平锁看起来很不错，不过要实现公平锁，系统内部肯定需要维护一个有序队列，因此公平锁的实现成本比较高，性能相对于非公平锁来说相对低一些。因此，在默认情况下，锁是非公平的，如果没有特别要求，则不建议使用公平锁。
公平锁和非公平锁在程序调度上是很不一样，来一个公平锁示例看一下：
package com.itsoku.chat06;
import java.util.concurrent.locks.ReentrantLock;
/
微信公众号：程序员路人，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo5 {
private static int num = 0;
private static ReentrantLock fairLock = new ReentrantLock(true**);
**public** **static** **class** **T** **extends** **Thread** {<br /> **public** **T**(String name) {<br /> **super**(name);<br /> }@Override<br /> **public** **void** **run**() {<br /> **for** (**int** i = 0; i < 5; i++) {<br /> fairLock.lock();<br /> **try** {<br /> System.out.println(**this**.getName() + "获得锁!");<br /> } **finally** {<br /> fairLock.unlock();<br /> }<br /> }<br /> }<br /> }**public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br /> T t1 = **new** T("t1");<br /> T t2 = **new** T("t2");<br /> T t3 = **new** T("t3");t1.start();<br /> t2.start();<br /> t3.start();t1.join();<br /> t2.join();<br /> t3.join();<br /> }<br />}
运行结果输出：
t1获得锁!
t2获得锁!
t3获得锁!
t1获得锁!
t2获得锁!
t3获得锁!
t1获得锁!
t2获得锁!
t3获得锁!
t1获得锁!
t2获得锁!
t3获得锁!
t1获得锁!
t2获得锁!
t3获得锁!
看一下输出的结果，锁是按照先后顺序获得的。
修改一下上面代码，改为非公平锁试试，如下：
ReentrantLock fairLock = new ReentrantLock(false);
运行结果如下：
t1获得锁!
t3获得锁!
t3获得锁!
t3获得锁!
t3获得锁!
t1获得锁!
t1获得锁!
t1获得锁!
t1获得锁!
t2获得锁!
t2获得锁!
t2获得锁!
t2获得锁!
t2获得锁!
t3获得锁!
可以看到 t3 可能会连续获得锁，结果是比较随机的，不公平的。
ReentrantLock 获取锁的过程是可中断的
对于 synchronized 关键字，如果一个线程在等待获取锁，最终只有 2 种结果：
- 要么获取到锁然后继续后面的操作
- 要么一直等待，直到其他线程释放锁为止
而 ReentrantLock 提供了另外一种可能，就是在等待获取锁的过程中（发起获取锁请求到还未获取到锁这段时间内）是可以被中断的，也就是说在等待锁的过程中，程序可以根据需要取消获取锁的请求。有些使用这个操作是非常有必要的。比如：你和好朋友越好一起去打球，如果你等了半小时朋友还没到，突然你接到一个电话，朋友由于突发状况，不能来了，那么你一定打道回府。中断操作正是提供了一套类似的机制，如果一个线程正在等待获取锁，那么它依然可以收到一个通知，被告知无需等待，可以停止工作了。
示例代码：
package com.itsoku.chat06;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
/
微信公众号：程序员路人，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo6 {
private static ReentrantLock lock1 = new ReentrantLock(false);
private static ReentrantLock lock2 = new ReentrantLock(false**);
**public** **static** **class** **T** **extends** **Thread** {<br /> **int** lock;**public** **T**(String name, **int** lock) {<br /> **super**(name);<br /> **this**.lock = lock;<br /> }@Override<br /> **public** **void** **run**() {<br /> **try** {<br /> **if** (**this**.lock == 1) {<br /> lock1.lockInterruptibly();<br /> TimeUnit.SECONDS.sleep(1);<br /> lock2.lockInterruptibly();<br /> } **else** {<br /> lock2.lockInterruptibly();<br /> TimeUnit.SECONDS.sleep(1);<br /> lock1.lockInterruptibly();<br /> }<br /> } **catch** (InterruptedException e) {<br /> System.out.println("中断标志:" + **this**.isInterrupted());<br /> e.printStackTrace();<br /> } **finally** {<br /> **if** (lock1.isHeldByCurrentThread()) {<br /> lock1.unlock();<br /> }<br /> **if** (lock2.isHeldByCurrentThread()) {<br /> lock2.unlock();<br /> }<br /> }<br /> }<br /> }**public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br /> T t1 = **new** T("t1", 1);<br /> T t2 = **new** T("t2", 2);t1.start();<br /> t2.start();<br /> }<br />}
先运行一下上面代码，发现程序无法结束，使用 jstack 查看线程堆栈信息，发现 2 个线程死锁了。
Found one Java-level deadlock:
=============================
“t2”:
waiting for ownable synchronizer 0x0000000717380c20, (a java.util.concurrent.locks.ReentrantLock$NonfairSync),
which is held by “t1”
“t1”:
waiting for ownable synchronizer 0x0000000717380c50, (a java.util.concurrent.locks.ReentrantLock$NonfairSync),
which is held by “t2”
lock1 被线程 t1 占用，lock2 被线程 t2 占用，线程 t1 在等待获取 lock2，线程 t2 在等待获取 lock1，都在相互等待获取对方持有的锁，最终产生了死锁，如果是在 synchronized 关键字情况下发生了死锁现象，程序是无法结束的。
我们对上面代码改造一下，线程 t2 一直无法获取到 lock1，那么等待 5 秒之后，我们中断获取锁的操作。主要修改一下 main 方法，如下：
T t1 = new T(“t1”, 1);
T t2 = new T(“t2”, 2);
t1.start();
t2.start();
TimeUnit.SECONDS.sleep(5);
t2.interrupt();
新增了 2 行代码TimeUnit.SECONDS.sleep(5);t2.interrupt();，程序可以结束了，运行结果：
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 com.itsoku.chat06.Demo6$T.run(Demo6.java:31)
中断标志:false
从上面信息中可以看出，代码的 31 行触发了异常，中断标志输出：false
](img/1.png)
t2 在 31 行一直获取不到 lock1 的锁，主线程中等待了 5 秒之后，t2 线程调用了interrupt()方法，将线程的中断标志置为 true，此时 31 行会触发InterruptedException异常，然后线程 t2 可以继续向下执行，释放了 lock2 的锁，然后线程 t1 可以正常获取锁，程序得以继续进行。线程发送中断信号触发 InterruptedException 异常之后，中断标志将被清空。
关于获取锁的过程中被中断，注意几点:
- ReentrankLock 中必须使用实例方法lockInterruptibly()获取锁时，在线程调用 interrupt()方法之后，才会引发InterruptedException异常
- 线程调用 interrupt()之后，线程的中断标志会被置为 true
- 触发 InterruptedException 异常之后，线程的中断标志会被清空，即置为 false
- 所以当线程调用 interrupt()引发 InterruptedException 异常，中断标志的变化是:false->true->false
ReentrantLock 锁申请等待限时
申请锁等待限时是什么意思？一般情况下，获取锁的时间我们是不知道的，synchronized 关键字获取锁的过程中，只能等待其他线程把锁释放之后才能够有机会获取到锁。所以获取锁的时间有长有短。如果获取锁的时间能够设置超时时间，那就非常好了。
ReentrantLock 刚好提供了这样功能，给我们提供了获取锁限时等待的方法tryLock()，可以选择传入时间参数，表示等待指定的时间，无参则表示立即返回锁申请的结果：true 表示获取锁成功，false 表示获取锁失败。tryLock 无参方法
看一下源码中 tryLock 方法：
public boolean tryLock()
返回 boolean 类型的值，此方法会立即返回，结果表示获取锁是否成功，示例：
package com.itsoku.chat06;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
/
微信公众号：程序员路人，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo8 {
private static ReentrantLock lock1 = new ReentrantLock(false**);
public static class T extends Thread {public T(String name) {<br /> super(name);<br /> }@Override<br /> public void **run**() {<br /> try {<br /> System.out.println(System.currentTimeMillis() + ":" + this.getName() + "开始获取锁!");<br /> //获取锁超时时间设置为3秒，3秒内是否能否获取锁都会返回<br /> **if** (lock1.tryLock()) {<br /> System.out.println(System.currentTimeMillis() + ":" + this.getName() + "获取到了锁!");<br /> //获取到锁之后，休眠5秒<br /> TimeUnit.SECONDS.sleep(5);<br /> } **else** {<br /> System.out.println(System.currentTimeMillis() + ":" + this.getName() + "未能获取到锁!");<br /> }<br /> } catch (InterruptedException e) {<br /> e.printStackTrace();<br /> } finally {<br /> **if** (lock1.isHeldByCurrentThread()) {<br /> lock1.unlock();<br /> }<br /> }<br /> }<br /> }public static void main(String[] args) throws InterruptedException {<br /> T t1 = new T("t1");<br /> T t2 = new T("t2");t1.start();<br /> t2.start();<br /> }<br />}
代码中获取锁成功之后，休眠 5 秒，会导致另外一个线程获取锁失败，运行代码，输出：
1563356291081:t2开始获取锁!
1563356291081:t2获取到了锁!
1563356291081:t1开始获取锁!
1563356291081:t1未能获取到锁!
可以看到 t2 获取成功，t1 获取失败了，tryLock()是立即响应的，中间不会有阻塞。
tryLock 有参方法
可以明确设置获取锁的超时时间，该方法签名：
public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException
该方法在指定的时间内不管是否可以获取锁，都会返回结果，返回 true，表示获取锁成功，返回 false 表示获取失败。此方法有 2 个参数，第一个参数是时间类型，是一个枚举，可以表示时、分、秒、毫秒等待，使用比较方便，第 1 个参数表示在时间类型上的时间长短。此方法在执行的过程中，如果调用了线程的中断 interrupt()方法，会触发 InterruptedException 异常。
示例：
package com.itsoku.chat06;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
/
微信公众号：程序员路人，专注于java技术分享（带你玩转 爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！
/
public class Demo7 {
private static ReentrantLock lock1 = new ReentrantLock(false**);
**public** **static** **class** **T** **extends** **Thread** {**public** **T**(String name) {<br /> **super**(name);<br /> }@Override<br /> **public** **void** **run**() {<br /> **try** {<br /> System.out.println(System.currentTimeMillis() + ":" + **this**.getName() + "开始获取锁!");<br /> //获取锁超时时间设置为3秒，3秒内是否能否获取锁都会返回<br /> **if** (lock1.tryLock(3, TimeUnit.SECONDS)) {<br /> System.out.println(System.currentTimeMillis() + ":" + **this**.getName() + "获取到了锁!");<br /> //获取到锁之后，休眠5秒<br /> TimeUnit.SECONDS.sleep(5);<br /> } **else** {<br /> System.out.println(System.currentTimeMillis() + ":" + **this**.getName() + "未能获取到锁!");<br /> }<br /> } **catch** (InterruptedException e) {<br /> e.printStackTrace();<br /> } **finally** {<br /> **if** (lock1.isHeldByCurrentThread()) {<br /> lock1.unlock();<br /> }<br /> }<br /> }<br /> }**public** **static** **void** **main**(String[] args) **throws** InterruptedException {<br /> T t1 = **new** T("t1");<br /> T t2 = **new** T("t2");t1.start();<br /> t2.start();<br /> }<br />}
程序中调用了 ReentrantLock 的实例方法tryLock(3, TimeUnit.SECONDS)，表示获取锁的超时时间是 3 秒，3 秒后不管是否能否获取锁，该方法都会有返回值，获取到锁之后，内部休眠了 5 秒，会导致另外一个线程获取锁失败。
运行程序，输出：
1563355512901:t2开始获取锁!
1563355512901:t1开始获取锁!
1563355512902:t2获取到了锁!
1563355515904:t1未能获取到锁!
输出结果中分析，t2 获取到锁了，然后休眠了 5 秒，t1 获取锁失败，t1 打印了 2 条信息，时间相差 3 秒左右。
关于 tryLock()方法和 tryLock(long timeout, TimeUnit unit)方法，说明一下：
- 都会返回 boolean 值，结果表示获取锁是否成功
- tryLock()方法，不管是否获取成功，都会立即返回；而有参的 tryLock 方法会尝试在指定的时间内去获取锁，中间会阻塞的现象，在指定的时间之后会不管是否能够获取锁都会返回结果
tryLock()方法不会响应线程的中断方法；而有参的 tryLock 方法会响应线程的中断方法，而触发InterruptedException异常，这个从 2 个方法的声明上可以可以看出来
ReentrantLock 其他常用的方法
isHeldByCurrentThread：实例方法，判断当前线程是否持有 ReentrantLock 的锁，上面代码中有使用过。
获取锁的 4 种方法对比
| 获取锁的方法 | 是否立即响应(不会阻塞) | 是否响应中断 | | —- | —- | —- | | lock() | × | × | | lockInterruptibly() | × | √ | | tryLock() | √ | × | | tryLock(long timeout, TimeUnit unit) | × | √ |
总结
- ReentrantLock 可以实现公平锁和非公平锁
- ReentrantLock 默认实现的是非公平锁
- ReentrantLock 的获取锁和释放锁必须成对出现，锁了几次，也要释放几次
- 释放锁的操作必须放在 finally 中执行
- lockInterruptibly()实例方法可以响应线程的中断方法，调用线程的 interrupt()方法时，lockInterruptibly()方法会触发InterruptedException异常
- 关于InterruptedException异常说一下，看到方法声明上带有 throws InterruptedException，表示该方法可以响应线程中断，调用线程的 interrupt()方法时，这些方法会触发InterruptedException异常，触发 InterruptedException 时，线程的中断中断状态会被清除。所以如果程序由于调用interrupt()方法而触发InterruptedException异常，线程的标志由默认的 false 变为 ture，然后又变为 false
- 实例方法 tryLock()会尝试获取锁，会立即返回，返回值表示是否获取成功
- 实例方法 tryLock(long timeout, TimeUnit unit)会在指定的时间内尝试获取锁，指定的时间内是否能够获取锁，都会返回，返回值表示是否获取锁成功，该方法会响应线程的中断
若有收获，就点个赞吧
0 人点赞
