java高并发系列 - 第12天JUC：ReentrantLock重入锁

最新推荐文章于 2024-05-18 16:42:38 发布

2401_83977716

最新推荐文章于 2024-05-18 16:42:38 发布

阅读量411

点赞数 22

分类专栏：程序员文章标签： java 开发语言

本文链接：https://blog.csdn.net/2401_83977716/article/details/138328825

版权

程序员专栏收录该内容

191 篇文章 0 订阅

订阅专栏

t3.join();

}

运行结果输出：

t1获得锁!

t2获得锁!

t3获得锁!

t1获得锁!

t2获得锁!

t3获得锁!

t1获得锁!

t2获得锁!

t3获得锁!

t1获得锁!

t2获得锁!

t3获得锁!

t1获得锁!

t2获得锁!

t3获得锁!

看一下输出的结果，锁时按照先后顺序获得的。

修改一下上面代码，改为非公平锁试试，如下：

ReentrantLock fairLock = new ReentrantLock(false);

运行结果如下：

t1获得锁!

t3获得锁!

t1获得锁!

t2获得锁!

t3获得锁!

可以看到t3可能会连续获得锁，结果是比较随机的，不公平的。

ReentrantLock获取锁的过程是可中断的

对于synchronized关键字，如果一个线程在等待获取锁，最终只有2种结果：

要么获取到锁然后继续后面的操作
要么一直等待，直到其他线程释放锁为止

而ReentrantLock提供了另外一种可能，就是在等的获取锁的过程中（发起获取锁请求到还未获取到锁这段时间内）是可以被中断的，也就是说在等待锁的过程中，程序可以根据需要取消获取锁的请求。有些使用这个操作是非常有必要的。比如：你和好朋友越好一起去打球，如果你等了半小时朋友还没到，突然你接到一个电话，朋友由于突发状况，不能来了，那么你一定达到回府。中断操作正是提供了一套类似的机制，如果一个线程正在等待获取锁，那么它依然可以收到一个通知，被告知无需等待，可以停止工作了。

示例代码：

package com.itsoku.chat06;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.locks.ReentrantLock;

/**

微信公众号：路人甲Java，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

public class Demo6 {

private static ReentrantLock lock1 = new ReentrantLock(false);

private static ReentrantLock lock2 = new ReentrantLock(false);

public static class T extends Thread {

int lock;

public T(String name, int lock) {

super(name);

this.lock = lock;

}

@Override

public void run() {

try {

if (this.lock == 1) {

lock1.lockInterruptibly();

TimeUnit.SECONDS.sleep(1);

lock2.lockInterruptibly();

} else {

lock2.lockInterruptibly();

TimeUnit.SECONDS.sleep(1);

lock1.lockInterruptibly();

}

} catch (InterruptedException e) {

System.out.println(“中断标志:” + this.isInterrupted());

e.printStackTrace();

} finally {

if (lock1.isHeldByCurrentThread()) {

lock1.unlock();

}

if (lock2.isHeldByCurrentThread()) {

lock2.unlock();

}

public static void main(String[] args) throws InterruptedException {

T t1 = new T(“t1”, 1);

T t2 = new T(“t2”, 2);

t1.start();

t2.start();

}

先运行一下上面代码，发现程序无法结束，使用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

640?wx_fmt=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，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

public class Demo8 {

private static ReentrantLock lock1 = new ReentrantLock(false);

public static class T extends Thread {

public T(String name) {

super(name);

}

@Override

public void run() {

try {

System.out.println(System.currentTimeMillis() + “:” + this.getName() + “开始获取锁!”);

//获取锁超时时间设置为3秒，3秒内是否能否获取锁都会返回

if (lock1.tryLock()) {

System.out.println(System.currentTimeMillis() + “:” + this.getName() + “获取到了锁!”);

//获取到锁之后，休眠5秒

TimeUnit.SECONDS.sleep(5);

} else {

System.out.println(System.currentTimeMillis() + “:” + this.getName() + “未能获取到锁!”);

}

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

if (lock1.isHeldByCurrentThread()) {

lock1.unlock();

}

public static void main(String[] args) throws InterruptedException {

T t1 = new T(“t1”);

T t2 = new T(“t2”);

t1.start();

t2.start();

}

代码中获取锁成功之后，休眠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，专注于java技术分享（带你玩转爬虫、分布式事务、异步消息服务、任务调度、分库分表、大数据等），喜欢请关注！

public class Demo7 {

private static ReentrantLock lock1 = new ReentrantLock(false);

public static class T extends Thread {

public T(String name) {

super(name);

}

@Override

public void run() {

try {

System.out.println(System.currentTimeMillis() + “:” + this.getName() + “开始获取锁!”);

//获取锁超时时间设置为3秒，3秒内是否能否获取锁都会返回

if (lock1.tryLock(3, TimeUnit.SECONDS)) {

System.out.println(System.currentTimeMillis() + “:” + this.getName() + “获取到了锁!”);

//获取到锁之后，休眠5秒

TimeUnit.SECONDS.sleep(5);

} else {

System.out.println(System.currentTimeMillis() + “:” + this.getName() + “未能获取到锁!”);

}

} catch (InterruptedException e) {

e.printStackTrace();

} finally {

if (lock1.isHeldByCurrentThread()) {

lock1.unlock();

}

public static void main(String[] args) throws InterruptedException {

T t1 = new T(“t1”);

T t2 = new T(“t2”);

t1.start();

t2.start();

}

程序中调用了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异常说一下，看到方法声明上带有 throwsInterruptedException，表示该方法可以相应线程中断，调用线程的interrupt()方法时，这些方法会触发 InterruptedException异常，触发InterruptedException时，线程的中断中断状态会被清除。所以如果程序由于调用 interrupt()方法而触发 InterruptedException异常，线程的标志由默认的false变为ture，然后又变为false
实例方法tryLock()获会尝试获取锁，会立即返回，返回值表示是否获取成功
实例方法tryLock(long timeout, TimeUnit unit)会在指定的时间内尝试获取锁，指定的时间内是否能够获取锁，都会返回，返回值表示是否获取锁成功，该方法会响应线程的中断