ReentrantLock 中的 4 个坑！

时间 2021-08-13

标签 java 安全并发 ide post 性能学习优化 this 线程栏目 Java 繁體版

原文原文链接

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

前面的文章咱们已经介绍了 synchronized，详见如下列表：
《synchronized 加锁 this 和 class 的区别！》
《synchronized 优化手段之锁膨胀机制！》
《synchronized 中的 4 个优化，你知道几个？》安全

因此本文我们重点来看 Lock。并发

Lock 简介

Lock 是一个顶级接口，它的全部方法以下图所示：

它的子类列表以下：

咱们一般会使用 ReentrantLock 来定义其实例，它们之间的关联以下图所示：
ide

PS：Sync 是同步锁的意思，FairSync 是公平锁，NonfairSync 是非公平锁。post

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 默认状况下为非公平锁。this

想要将 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 代码中，可能会致使两个问题：

未加锁成功就执行了释放锁的操做，从而致使了新的异常；
释放锁的异常会覆盖程序原有的异常，从而增长了排查问题的难度。

总结

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

默认状况下 ReentrantLock 为非公平锁而非公平锁；
加锁次数和释放锁次数必定要保持一致，不然会致使线程阻塞或程序异常；
加锁操做必定要放在 try 代码以前，这样能够避免未加锁成功又释放锁的异常；
释放锁必定要放在 finally 中，不然会致使线程阻塞。

本系列推荐文章

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