作者 | 王磊
创新互联建站坚持“要么做到,要么别承诺”的工作理念,服务领域包括:成都网站建设、网站建设、企业官网、英文网站、手机端网站、网站推广等服务,满足客户于互联网时代的三明网站设计、移动媒体设计的需求,帮助企业找到有效的互联网解决方案。努力成为您成熟可靠的网络建设合作伙伴!
来源 | Java中文社群(ID:javacn666)
转载请联系授权(微信ID:GG_Stone)
JDK 1.5 之前 synchronized 的性能是比较低的,但在 JDK 1.5 中,官方推出一个重量级功能 Lock,一举改变了 Java 中锁的格局。JDK 1.5 之前当我们谈到锁时,只能使用内置锁 synchronized,但如今我们锁的实现又多了一种显式锁 Lock。
本文咱们重点来看 Lock。
Lock 是一个顶级接口,它的所有方法如下图所示:
它的子类列表如下:
我们通常会使用 ReentrantLock 来定义其实例,它们之间的关联如下图所示:
“PS:Sync 是同步锁的意思,FairSync 是公平锁,NonfairSync 是非公平锁。
学习任何一项技能都是先从使用开始的,所以我们也不例外,咱们先来看下 ReentrantLock 的基础使用:
- publicclass LockExample {
- // 创建锁对象
- privatefinal ReentrantLock lock = new ReentrantLock();
- public void method() {
- // 加锁操作
- lock.lock();
- try {
- // 业务代码......
- } finally {
- // 释放锁
- lock.unlock();
- }
- }
- }
ReentrantLock 在创建之后,有两个关键性的操作:
很多人会认为(尤其是新手朋友),ReentrantLock 默认的实现是公平锁,其实并非如此,ReentrantLock 默认情况下为非公平锁(这主要是出于性能方面的考虑),比如下面这段代码:
- import java.util.concurrent.locks.ReentrantLock;
- publicclass LockExample {
- // 创建锁对象
- privatestaticfinal 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;
- publicclass LockExample {
- // 创建锁对象(公平锁)
- privatestaticfinal 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 时,它就会创建一个公平锁。
使用 ReentrantLock 时一定要记得释放锁,否则就会导致该锁一直被占用,其他使用该锁的线程则会永久的等待下去,所以我们在使用 ReentrantLock 时,一定要在 finally 中释放锁,这样就可以保证锁一定会被释放。
- import java.util.concurrent.locks.ReentrantLock;
- publicclass LockExample {
- // 创建锁对象
- privatestaticfinal 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;
- publicclass LockExample {
- // 创建锁对象
- privatestaticfinal 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 锁的释放操作,这样其他使用此锁的线程就可以正常获取并运行了。
lock 操作的次数和 unlock 操作的次数必须一一对应,且不能出现一个锁被释放多次的情况,因为这样就会导致程序报错。
一次 lock 对应了两次 unlock 操作,导致程序报错并终止执行,示例代码如下:
- import java.util.concurrent.locks.ReentrantLock;
- publicclass LockExample {
- // 创建锁对象
- privatestaticfinal 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 时,程序报错并终止执行了,导致异常之后的代码都未正常执行。
在使用 ReentrantLock 时,需要注意不要将加锁操作放在 try 代码中,这样会导致未加锁成功就执行了释放锁的操作,从而导致程序执行异常。
- import java.util.concurrent.locks.ReentrantLock;
- publicclass LockExample {
- // 创建锁对象
- privatestaticfinal 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中的四个坑!
本文路径:http://www.csdahua.cn/qtweb/news3/228553.html
网站建设、网络推广公司-快上网,是专注品牌与效果的网站制作,网络营销seo公司;服务项目有等
声明:本网站发布的内容(图片、视频和文字)以用户投稿、用户转载内容为主,如果涉及侵权请尽快告知,我们将会在第一时间删除。文章观点不代表本网站立场,如需处理请联系客服。电话:028-86922220;邮箱:631063699@qq.com。内容未经允许不得转载,或转载时需注明来源: 快上网