写点什么

ReentrantLock 中的 4 个坑!

用户头像
王磊
关注
发布于: 2 小时前
ReentrantLock 中的 4 个坑!

JDK 1.5 之前 synchronized 的性能是比较低的,但在 JDK 1.5 中,官方推出一个重量级功能 Lock,一举改变了 Java 中锁的格局。JDK 1.5 之前当我们谈到锁时,只能使用内置锁 synchronized,但如今我们锁的实现又多了一种显式锁 Lock。


前面的文章我们已经介绍了 synchronized,详见以下列表:《synchronized 加锁 this 和 class 的区别!》《synchronized 优化手段之锁膨胀机制!》《synchronized 中的 4 个优化,你知道几个?》


所以本文咱们重点来看 Lock。

Lock 简介

Lock 是一个顶级接口,它的所有方法如下图所示:



它的子类列表如下:



我们通常会使用 ReentrantLock 来定义其实例,它们之间的关联如下图所示:



PS:Sync 是同步锁的意思,FairSync 是公平锁,NonfairSync 是非公平锁。

ReentrantLock 使用

学习任何一项技能都是先从使用开始的,所以我们也不例外,咱们先来看下 ReentrantLock 的基础使用:


public class LockExample {    // 创建锁对象    private final ReentrantLock lock = new ReentrantLock();    public void method() {        // 加锁操作        lock.lock();        try {            // 业务代码......        } finally {            // 释放锁            lock.unlock();        }    }}
复制代码


ReentrantLock 在创建之后,有两个关键性的操作:


  • 加锁操作:lock()

  • 释放锁操作:unlock()

ReentrantLock 中的坑

1.ReentrantLock 默认为非公平锁

很多人会认为(尤其是新手朋友),ReentrantLock 默认的实现是公平锁,其实并非如此,ReentrantLock 默认情况下为非公平锁(这主要是出于性能方面的考虑),比如下面这段代码:


import java.util.concurrent.locks.ReentrantLock;
public class LockExample { // 创建锁对象 private static final ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) { // 定义线程任务 Runnable runnable = new Runnable() { @Override public void run() { // 加锁 lock.lock(); try { // 打印执行线程的名字 System.out.println("线程:" + Thread.currentThread().getName()); } finally { // 释放锁 lock.unlock(); } } }; // 创建多个线程 for (int i = 0; i < 10; i++) { new Thread(runnable).start(); } }}
复制代码


以上程序的执行结果如下:



从上述执行的结果可以看出,ReentrantLock 默认情况下为非公平锁。因为线程的名称是根据创建的先后顺序递增的,所以如果是公平锁,那么线程的执行应该是有序递增的,但从上述的结果可以看出,线程的执行和打印是无序的,这说明 ReentrantLock 默认情况下为非公平锁。


想要将 ReentrantLock 设置为公平锁也很简单,只需要在创建 ReentrantLock 时,设置一个 true 的构造参数就可以了,如下代码所示:


import java.util.concurrent.locks.ReentrantLock;
public class LockExample { // 创建锁对象(公平锁) private static final ReentrantLock lock = new ReentrantLock(true);
public static void main(String[] args) { // 定义线程任务 Runnable runnable = new Runnable() { @Override public void run() { // 加锁 lock.lock(); try { // 打印执行线程的名字 System.out.println("线程:" + Thread.currentThread().getName()); } finally { // 释放锁 lock.unlock(); } } }; // 创建多个线程 for (int i = 0; i < 10; i++) { new Thread(runnable).start(); } }}
复制代码


以上程序的执行结果如下:



从上述结果可以看出,当我们显式的给 ReentrantLock 设置了 true 的构造参数之后,ReentrantLock 就变成了公平锁,线程获取锁的顺序也变成有序的了。


其实从 ReentrantLock 的源码我们也可以看出它究竟是公平锁还是非公平锁,ReentrantLock 部分源码实现如下:


 public ReentrantLock() {     sync = new NonfairSync(); }public ReentrantLock(boolean fair) {    sync = fair ? new FairSync() : new NonfairSync();}
复制代码


从上述源码中可以看出,默认情况下 ReentrantLock 会创建一个非公平锁,如果在创建时显式的设置构造参数的值为 true 时,它就会创建一个公平锁。

2.在 finally 中释放锁

使用 ReentrantLock 时一定要记得释放锁,否则就会导致该锁一直被占用,其他使用该锁的线程则会永久的等待下去,所以我们在使用 ReentrantLock 时,一定要在 finally 中释放锁,这样就可以保证锁一定会被释放。

反例

import java.util.concurrent.locks.ReentrantLock;
public class LockExample { // 创建锁对象 private static final ReentrantLock lock = new ReentrantLock(); public static void main(String[] args) { // 加锁操作 lock.lock(); System.out.println("Hello,ReentrantLock."); // 此处会报异常,导致锁不能正常释放 int number = 1 / 0; // 释放锁 lock.unlock(); System.out.println("锁释放成功!"); }}
复制代码


以上程序的执行结果如下:



从上述结果可以看出,当出现异常时锁未被正常释放,这样就会导致其他使用该锁的线程永久的处于等待状态。

正例

import java.util.concurrent.locks.ReentrantLock;
public class LockExample { // 创建锁对象 private static final ReentrantLock lock = new ReentrantLock(); public static void main(String[] args) { // 加锁操作 lock.lock(); try { System.out.println("Hello,ReentrantLock."); // 此处会报异常 int number = 1 / 0; } finally { // 释放锁 lock.unlock(); System.out.println("锁释放成功!"); } }}
复制代码


以上程序的执行结果如下:



从上述结果可以看出,虽然方法中出现了异常情况,但并不影响 ReentrantLock 锁的释放操作,这样其他使用此锁的线程就可以正常获取并运行了。

3.锁不能被释放多次

lock 操作的次数和 unlock 操作的次数必须一一对应,且不能出现一个锁被释放多次的情况,因为这样就会导致程序报错。

反例

一次 lock 对应了两次 unlock 操作,导致程序报错并终止执行,示例代码如下:


import java.util.concurrent.locks.ReentrantLock;
public class LockExample { // 创建锁对象 private static final ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) { // 加锁操作 lock.lock(); // 第一次释放锁 try { System.out.println("执行业务 1~"); // 业务代码 1...... } finally { // 释放锁 lock.unlock(); System.out.println("锁释锁"); }
// 第二次释放锁 try { System.out.println("执行业务 2~"); // 业务代码 2...... } finally { // 释放锁 lock.unlock(); System.out.println("锁释锁"); } // 最后的打印操作 System.out.println("程序执行完成."); }}
复制代码


以上程序的执行结果如下:



从上述结果可以看出,执行第 2 个 unlock 时,程序报错并终止执行了,导致异常之后的代码都未正常执行。

4.lock 不要放在 try 代码内

在使用 ReentrantLock 时,需要注意不要将加锁操作放在 try 代码中,这样会导致未加锁成功就执行了释放锁的操作,从而导致程序执行异常。

反例

import java.util.concurrent.locks.ReentrantLock;
public class LockExample { // 创建锁对象 private static final ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) { try { // 此处异常 int num = 1 / 0; // 加锁操作 lock.lock(); } finally { // 释放锁 lock.unlock(); System.out.println("锁释锁"); } System.out.println("程序执行完成."); }}
复制代码


以上程序的执行结果如下:



从上述结果可以看出,如果将加锁操作放在 try 代码中,可能会导致两个问题:


  1. 未加锁成功就执行了释放锁的操作,从而导致了新的异常;

  2. 释放锁的异常会覆盖程序原有的异常,从而增加了排查问题的难度。

总结

本文介绍了 Java 中的显式锁 Lock 及其子类 ReentrantLock 的使用和注意事项,Lock 在 Java 中占据了锁的半壁江山,但在使用时却要注意 4 个问题:


  1. 默认情况下 ReentrantLock 为非公平锁而非公平锁;

  2. 加锁次数和释放锁次数一定要保持一致,否则会导致线程阻塞或程序异常;

  3. 加锁操作一定要放在 try 代码之前,这样可以避免未加锁成功又释放锁的异常;

  4. 释放锁一定要放在 finally 中,否则会导致线程阻塞。

本系列推荐文章

  1. 线程的 4 种创建方法和使用详解!

  2. Java中用户线程和守护线程区别这么大?

  3. 深入理解线程池 ThreadPool

  4. 线程池的7种创建方式,强烈推荐你用它...

  5. 池化技术到达有多牛?看了线程和线程池的对比吓我一跳!

  6. 并发中的线程同步与锁

  7. synchronized 加锁 this 和 class 的区别!

  8. volatile 和 synchronized 的区别

  9. 轻量级锁一定比重量级锁快吗?

  10. 这样终止线程,竟然会导致服务宕机?

  11. SimpleDateFormat线程不安全的5种解决方案!

  12. ThreadLocal不好用?那是你没用对!

  13. ThreadLocal内存溢出代码演示和原因分析!

  14. Semaphore自白:限流器用我就对了!

  15. CountDownLatch:别浪,等人齐再团!

  16. CyclicBarrier:人齐了,司机就可以发车了!

  17. synchronized 优化手段之锁膨胀机制

  18. synchronized 中的 4 个优化,你知道几个?


关注公号「Java 中文社群」查看更多有意思、涨知识的 Java 并发文章。

用户头像

王磊

关注

公众号:Java中文社群 2018.08.25 加入

公众号:Java中文社群

评论

发布
暂无评论
ReentrantLock 中的 4 个坑!