Java并发编程之ReentrantLock可重入锁的实例代码
作者：Java硬件工程师 发布时间：2021-12-10 06:05:50
目录 1.ReentrantLock可重入锁概述2.可重入3.可打断4.锁超时5.公平锁6.条件变量 Condition
1.ReentrantLock可重入锁概述
相对于 synchronized 它具备如下特点
可中断
synchronized锁加上去不能中断，a线程应用锁，b线程不能取消掉它
可以设置超时时间
synchronized它去获取锁时，如果对方持有锁，那么它就会进入entryList一直等待下去。而可重入锁可以设置超时时间，规定时间内如果获取不到锁，就放弃锁
可以设置为公平锁
防止线程饥饿的情况，即先到先得。如果争抢的人比较多，则可能会发生永远都得不到锁
支持多个条件变量多个waitset（不支持条件一的去a不支持条件二的去b）
synchronized只支持同一个waitset.
与 synchronized 一样，都支持可重入
基本语法
// 获取锁
reentrantLock.lock();
try {
// 临界区
} finally {
// 释放锁
reentrantLock.unlock();
}
synchronized是在关键字的级别来保护临界区，而reentrantLock是在对象的级别保护临界区。临界区即访问共享资源的那段代码。finally中表明不管将来是否出现异常，都会释放锁，释放锁即调用unlock方法。否则无法释放锁，其它线程就永远也获取不了锁。
2.可重入
可重入是指同一个线程如果首次获得了这把锁，那么因为它是这把锁的拥有者，因此有权利再次获取这把锁
如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住
ReentrantLock和synchronized都是可重入锁。
public class TestReentranLock1 {
static ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) {
method1();
}
public static void method1() {
lock.lock();
try {
System.out.println("execute method1");
method2();
} finally {
lock.unlock();
}
}
public static void method2() {
lock.lock();
try {
System.out.println("execute method2");
method3();
} finally {
lock.unlock();
}
}
public static void method3() {
lock.lock();
try {
System.out.println("execute method3");
} finally {
lock.unlock();
}
}
}
execute method1
execute method2
execute method3
3.可打断
可打断是指在等待锁的过程中，其它线程可以用interrupt方法终止我的等待。synchronized锁是不可打断的。
我们要想在等锁的过程中被打断，就要使用lockInterruptibly()方法对lock对象加锁，而不是lock()方法
public class TestReentranLock2 {
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
try {
//如果没有竞争，此方法就会获取lock对象的锁
//如果有竞争，就进入阻塞队列等待，可以被其它线程用interrupt打断
System.out.println("尝试获得锁");
lock.lockInterruptibly();
} catch (InterruptedException e) {
e.printStackTrace();
System.out.println("等锁的过程中被打断");
return;
}
try {
System.out.println("t1获得了锁");
} finally {
lock.unlock();
}
}, "t1");
lock.lock();
System.out.println("主线程获得了锁");
t1.start();
try {
try {
sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
t1.interrupt();
System.out.println("执行打断t1");
} finally {
lock.unlock();
}
}
}
主线程获得了锁
尝试获得锁
执行打断t1
等锁的过程中被打断
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 cn.yj.jvm.TestReentranLock2.lambda$main$0(TestReentranLock2.java:15)
at java.lang.Thread.run(Thread.java:748)
注意如果是不可中断模式，那么即使使用了 interrupt 也不会让等待中断，即不是。即使用lock()方法。
这种方式可以避免死锁情况的发生，避免无休止的等待。
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
System.out.println("启动...");
lock.lock();
try {
System.out.println("获得了锁");
} finally {
lock.unlock();
}
}, "t1");
lock.lock();
System.out.println("获得了锁");
t1.start();
try {
sleep(1);
t1.interrupt();
System.out.println("执行打断");
sleep(1);
} finally {
System.out.println("释放了锁");
lock.unlock();
}
4.锁超时
ReentranLock支持可打断，其实就是为了避免死等，这样就可以减少死锁的发生。实际上可打断这种方式属于一种被动的避免死等，是由其它线程interrupt来打断。
而锁超时是主动的方式避免死等的手段。
获取锁用tryLock()方法，即尝试获得锁，如果成功了，它就获得锁，如果失败了，它就可以不去进入阻塞队列等待，它就会返回false，表示没有获得锁。
立刻失败
public static void main(String[] args) {
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
System.out.println("启动...");
if (!lock.tryLock()) {
System.out.println("获取不到锁，立刻失败，返回");
return;
}
try {
System.out.println("获得了锁");
} finally {
lock.unlock();
}
}, "t1");
lock.lock();
System.out.println("获得了锁");
t1.start();
try {
try {
sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
} finally {
lock.unlock();
}
}
获得了锁
启动...
获取不到锁，立刻失败，返回
超时失败
lock.tryLock(1,TimeUnit.SECONDS)表示尝试等待1s，如果主线程不释放锁，那么它就会返回false，如果释放了锁，那么它就会返回true.tryLock也支持被打断，被打断时报异常。
ReentrantLock lock = new ReentrantLock();
Thread t1 = new Thread(() -> {
log.debug("启动...");
try {
if (!lock.tryLock(1, TimeUnit.SECONDS)) {
log.debug("获取等待 1s 后失败，返回");
return;
}
} catch (InterruptedException e) {
e.printStackTrace();
}
try {
log.debug("获得了锁");
} finally {
lock.unlock();
}
}, "t1");
lock.lock();
log.debug("获得了锁");
t1.start();
try {
sleep(2);
} finally {
lock.unlock();
}
输出
18:19:40.537 [main] c.TestTimeout - 获得了锁
18:19:40.544 [t1] c.TestTimeout - 启动...
18:19:41.547 [t1] c.TestTimeout - 获取等待 1s 后失败，返回
5.公平锁
对于synchronized来说，它是不公平的锁。当一个线程持有锁，其他线程就会进入阻塞队列等待，当锁的持有者释放锁的时候，这些线程就会一拥而上，谁先抢到，谁就成为monitor的主人，而不会按照先来先得的规则。
ReentrantLock 默认是不公平的
ReentrantLock有一个带参构造方法。默认是非公平的。
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
我们可以通过布尔值改成真，来保证它的公平性。即将来阻塞队列里的线程，争抢锁的时候会按照进入阻塞队列的顺序执行，先到先得。
6.条件变量 Condition
synchronized 中也有条件变量，就是我们讲原理时那个 waitSet 休息室，当条件不满足时进入 waitSet 等待
ReentrantLock 的条件变量比 synchronized 强大之处在于，它是支持多个条件变量的，这就好比
synchronized 是那些不满足条件的线程都在一间休息室等消息
而 ReentrantLock 支持多间休息室，有专门等烟的休息室、专门等早餐的休息室、唤醒时也是按休息室来唤醒
使用要点：
await 前需要获得锁
await 执行后，会释放锁，进入 conditionObject 等待
await 的线程被唤醒（或打断、或超时）取重新竞争 lock 锁
竞争 lock 锁成功后，从 await 后继续执行
signal 相当于 notify，signalAll 相当于 notifyAll
static ReentrantLock lock = new ReentrantLock();
static Condition waitCigaretteQueue = lock.newCondition();
static Condition waitbreakfastQueue = lock.newCondition();
static volatile boolean hasCigrette = false;
static volatile boolean hasBreakfast = false;
public static void main(String[] args) {
new Thread(() -> {
try {
lock.lock();
while (!hasCigrette) {
try {
waitCigaretteQueue.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
log.debug("等到了它的烟");
} finally {
lock.unlock();
}
}).start();
new Thread(() -> {
try {
lock.lock();
while (!hasBreakfast) {
try {
waitbreakfastQueue.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
log.debug("等到了它的早餐");
} finally {
lock.unlock();
}
}).start();
sleep(1);
sendBreakfast();
sleep(1);
sendCigarette();
}
private static void sendCigarette() {
lock.lock();
try {
log.debug("送烟来了");
hasCigrette = true;
waitCigaretteQueue.signal();
} finally {
lock.unlock();
}
}
private static void sendBreakfast() {
lock.lock();
try {
log.debug("送早餐来了");
hasBreakfast = true;
waitbreakfastQueue.signal();
} finally {
lock.unlock();
}
}
输出
18:52:27.680 [main] c.TestCondition - 送早餐来了
18:52:27.682 [Thread-1] c.TestCondition - 等到了它的早餐
18:52:28.683 [main] c.TestCondition - 送烟来了
18:52:28.683 [Thread-0] c.TestCondition - 等到了它的烟
来源：https://blog.csdn.net/qq_39736597/article/details/113701074
0
投稿猜你喜欢
自从使用 HttpClient 和 Jsoup 配合编写了几个简单的入门爬虫之后，发现对于绝对路径的需求是很频繁的，因为大部分的网页都写相对- 问题描述使用@Autowired处理多个同种类型的bean，出现@Value和@Bean的执行顺序问题。首先使用扫描包+注解的方式注册Use
- 本文实例讲述了Android使用ToggleButton实现开关效果的方法。分享给大家供大家参考，具体如下：activity_main.xm
- Java 15 在 2020 年 9 月发布，虽然不是长久支持版本，但是也带来了 14 个新功能，这些新功能中有不少是十分实用的。Java
- 本文实例总结了C#常见应用函数。分享给大家供大家参考，具体如下：1、页面写CS代码（代码内嵌）<％@ Import Namespace
- SpringCloud Zuul 是SpringCloud系列的网关实现,具有均衡负载,将非业务性校验剥离出来,使微服务专注于业务的一个组件
- 本文实例为大家分享了Android点击获取验证码倒计时的具体代码，供大家参考，具体内容如下package com.loaderman.cou
- C# 中同样支持多维数组（也可称为矩形数组），它可以是二维的，也可以是三维的，多维数组中的数据以类似表格（行、列）的形式存储，因此也被称为矩
- 项目需求：根据年级下拉框的变化使得科目下拉框绑定次年级下对应有的值我们用三层架构的模式来实现1.我们想和数据库交互，我们首先得来先解决DAL
- 本文介绍SpringBoot如何使用Prometheus配合Grafana监控。1.关于PrometheusPrometheus是一个根据应
- 这篇文章主要介绍了Spring Bean初始化及销毁多种实现方式,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值
- 一、常用的单位：相对单位主要有：px、sp、dp绝对单位主要有：pt、in、mm二、单位应用总结：一般用相对单位，而不是绝对单位1、字体的大
- logback filter过滤某个类 屏蔽某个类使用logback配置日志文件，有的时候需要我们过滤或者屏蔽掉某个类的日志，便可以通过以下
- MainActivity如下: package cn.testjavascript; import java.util.StringToke
- 声明：作者是根据 Hongyang的博客自己实践之后，根据自己的理解写的，有什么不对的地方还望指正。 先放两张效果图 一、准备由于Andro
- Mybatis删除多个数据例如：删除数据库中sid=1和sid=2的数据操作步骤如下1.在实体类中创建一个LIst用于存放要删除的sid2.
- 传值就是将实参的值传到所调用的函数里面，实参的值并没有发生变化，默认传值的有int型，浮点型，bo
- 前言但是在实际业务场景中，数据量迅速增长，一个库一个表已经满足不了我们的需求的时候，我们就会考虑分库分表的操作，在springboot中如何
- 前言该篇介绍的内容如题，就是利用redis实现接口的限流（ 某时间范围内 最大的访问次数 ） 。正文 惯例，
- 本文为大家分享了swing实现窗体拖拽和拉伸的具体代码，供大家参考，具体内容如下当用setUndecorated(true) 后 JFram
