ReentrantLock 使用

已于 2023-02-03 19:51:23 修改
阅读量556 收藏 1
点赞数
分类专栏： juc 文章标签： juc
于 2022-10-12 20:46:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51409098/article/details/127281422
版权

1、介绍

相对于 synchronized 它具备如下特点：

  • 可中断
  • 可以设置超时时间 
  • 可以设置为公平锁 
  • 支持多个条件变量

与 synchronized 一样，都支持可重入。

基本语法

// 获取锁
reentrantLock.lock();
try {
    // 临界区
} finally {
    // 释放锁 
    reentrantLock.unlock();
}

2、可重入

可重入是指同一个线程如果首次获得了这把锁，因为它是这把锁的拥有者，有权利再次获取这把锁。如果是不可重入锁，那么第二次获得锁时，自己也会被锁挡住。

    static ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) {
        method1();
    }

    public static void method1() {
        lock.lock();
        try {
            log.debug("execute method1");
            method2();
        } finally {
            lock.unlock();
        }
    }

    public static void method2() {
        lock.lock();
        try {
            log.debug("execute method2");
            method3();
        } finally {
            lock.unlock();
        }
    }

    public static void method3() {
        lock.lock();
        try {
            log.debug("execute method3");
        } finally {
            lock.unlock();
        }
    }

输出：

09:52:08.042 [main] DEBUG c.Test1 - execute method1
09:52:08.045 [main] DEBUG c.Test1 - execute method2
09:52:08.045 [main] DEBUG c.Test1 - execute method3

3、可打断

    ReentrantLock lock = new ReentrantLock();

    Thread t1 = new Thread(() -> {
        log.debug("启动...");
        try {
            //如果没有竞争那么此方法就会获取lock对象锁，
            //如果有竞争就进入阻塞队列，可以被其他线程用interrupt方法打断
            lock.lockInterruptibly();
        } catch (InterruptedException e) {
            e.printStackTrace();
            log.debug("等锁的过程中被打断");
            return;
        }
        try {
            log.debug("获得了锁");
        } finally {
            lock.unlock();
        }
    }, "t1");

    lock.lock(); //主线程首先获得锁
    log.debug("获得了锁");
    t1.start(); //t1线程进入阻塞队列
    try {
        TimeUnit.SECONDS.sleep(1);
        t1.interrupt(); //t1线程被打断，响应中断
        log.debug("执行打断");
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock();
    }

输出 

09:55:28.092 [main] DEBUG c.Test2 - 获得了锁
09:55:28.094 [t1] DEBUG c.Test2 - 启动...
09:55:29.095 [main] DEBUG c.Test2 - 执行打断
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 p4_13.Test2.lambda$main$0(Test2.java:22)
	at java.lang.Thread.run(Thread.java:748)
09:55:29.096 [t1] DEBUG c.Test2 - 等锁的过程中被打断

注意如果是不可中断模式，那么即使使用了 interrupt 也不会让等待中断。

    ReentrantLock lock = new ReentrantLock();

    Thread t1 = new Thread(() -> {
        log.debug("启动...");
        lock.lock();
        try {
            log.debug("获取了锁");
        }finally {
            lock.unlock();
        }
    }, "t1");

    lock.lock(); //主线程首先获得锁
    log.debug("获得了锁");
    t1.start(); //t1线程进入阻塞队列
    try {
        TimeUnit.SECONDS.sleep(1);
        t1.interrupt();
        log.debug("执行打断");
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock();
    }

输出

10:02:06.285 [main] DEBUG c.Test2 - 获得了锁
10:02:06.288 [t1] DEBUG c.Test2 - 启动...
10:02:07.290 [main] DEBUG c.Test2 - 执行打断
10:02:07.290 [t1] DEBUG c.Test2 - 获取了锁

4、锁超时

立刻失败

    ReentrantLock lock = new ReentrantLock();

    Thread t1 = new Thread(() -> {
        log.debug("启动...");
        if (!lock.tryLock()) {
            log.debug("获取立刻失败，返回");
            return;
        }
        try {
            log.debug("获得了锁");
        } finally {
            lock.unlock();
        }
    }, "t1");

    lock.lock(); //主线程获取锁
    log.debug("获得了锁");
    t1.start(); //子线程获取不到锁
    try {
        TimeUnit.SECONDS.sleep(2);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock();
    }

输出

10:07:14.085 [main] DEBUG c.Test3 - 获得了锁
10:07:14.089 [t1] DEBUG c.Test3 - 启动...
10:07:14.089 [t1] DEBUG c.Test3 - 获取立刻失败，返回

 超时失败

    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 {
        TimeUnit.SECONDS.sleep(2);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        lock.unlock();
    }

5、条件变量

synchronized 中也有条件变量，就是我们讲原理时那个 waitSet ，当条件不满足时进入 waitSet 等待。

ReentrantLock 的条件变量比 synchronized 强大之处在于，它是支持多个条件变量的，这就好比

  • synchronized 是那些不满足条件的线程都在一间休息室等消息
  • 而 ReentrantLock 支持多间休息室，有专门等烟的休息室、专门等早餐的休息室、唤醒时也是按休息室来唤醒

使用要点：

  • await 前需要获得锁
  • await 执行后，会释放锁，进入 conditionObject 等待
  • await 的线程被唤醒（或打断、或超时），重新竞争 lock 锁，竞争 lock 锁成功后，从 await 后继续执行
    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) throws InterruptedException {
        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();
        
        TimeUnit.SECONDS.sleep(1);
        sendBreakfast();
        TimeUnit.SECONDS.sleep(1);
        sendCigarette();
    }

    public static void sendCigarette(){
        lock.lock();
        try {
            log.debug("发烟了...");
            hasCigrette = true;
            waitCigaretteQueue.signal();
        }finally {
            lock.unlock();
        }
    }

    public static void sendBreakfast(){
        lock.lock();
        try {
            log.debug("早餐来了...");
            hasBreakfast = true;
            waitbreakfastQueue.signal();
        }finally {
            lock.unlock();
        }
    }

输出：

10:21:18.175 [main] DEBUG c.Test6 - 早餐来了...
10:21:18.183 [Thread-1] DEBUG c.Test6 - 等到了它的早餐
10:21:19.186 [main] DEBUG c.Test6 - 发烟了...
10:21:19.186 [Thread-0] DEBUG c.Test6 - 等到了它的烟
小鲁蛋儿
关注
专栏目录
使用ReentrantLock与wait()notifyAll对比实现线程通讯-生产者消费者模式
weixin_39276203的博客
03-05 639
实现目标： 1.ReentrantLock 建立一个容器，10个消费者，2个生产者，消费者消费数据，生产者生产数据。 容器中数据达到10，生产者等待，消费者进行消费 容器中数据为0，消费者等待，生产者进行生产 public class TestContainer<W> { List<W> list=Collections.synchronizedList(new ArrayList()); final static int MAX=10; static int
ReentrantLock实现wait和notify
qq_40698103的博客
08-16 1101
ReentrantLock可以配合Condition来实现wait和notify的await(）和signalAll（）来实现线程的等待和唤醒。 示例代码： public class TestClass { private final Lock lock = new ReentrantLock(); private final Condition condition = lock.newCondition(); private int count; public v.
并发系列（十一）----- ReentrantLock的使用
Alemand的博客
11-27 343
一 简介 ReentrantLock在中文的意思是重入锁与synchronized同步语意一样（具体的区别下面会总结），重入的意思是一个线程可以多次加锁，但是释放锁的时候要释放加锁的次数。ReentrantLock实现就是利用AQS独占模式，内部维护了一个AQS的子类Sync，Sync有两个子类FairSync和NofairSync这两个分别是ReentrantLock的两种锁，公平锁和非公平锁...
ReentrantLock之Condition用法和Synconsized的wait/notify方法
caijibaindashen的博客
05-01 368
二者异同 两者都是可重入锁，都是独占锁。 synchronized 依赖于 JVM 而 ReentrantLock 依赖于 API synchronized是非公平锁，而 ReentrantLock 既可以是公平锁，也可以是公平锁。 ReentrantLock 是等待可中断、可选择性通知。 ReentrantLock 的newContion（） public class Solution { static volatile int i = 0; static final Reentran
ReenTrantLock小记
积
01-08 349
lock()，lockInterruptibly()，tryLock()之间的区别： lock:此方法比较讲义气，如果他去拿锁时间发现别人在拿着锁，他就会蹲守这个锁并且一直等下去，即使其他线程中断（interrupt）了他所在的线程，他也不会告诉自己的调用层（自己内部消化这个线程的中断异常，猜测他所在的线程已经被中断（这样说的原因见下面的代码），他拿到锁之后他之后的任务的进行应该是有一种机制来实
Java中的显示锁ReentrantLock使用与原理详解
08-26
Java中的显示锁ReentrantLock使用与原理详解 Java中的显示锁ReentrantLock是Java concurrency API中的一种同步机制，用于解决多线程安全问题。ReentrantLock是Java 5中引入的，它是一种可重入锁，允许同一个线程多...
22. Java ReentrantLock 使用
最新发布
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-08 978
本节内容主要是对 ReentrantLock 的使用进行讲解，之前对于 Lock 接口进行了讲解，ReentrantLock 是 Lock 接口的常用实现子类，占据着十分重要的地位。ReentrantLock 基本方法的使用，即 lock 与 unlock 方法的使用，这是最基础的方法使用，为重点内容；ReentrantLock lockInterruptibly 与 tryLock 方法的使用，也是经常使用到的方法，为本节重点内容；
ReentrantLock使用场景和实例
zhaoyunfei1的博客
04-08 2463
转载来源： 使用场景：https://my.oschina.net/noahxiao/blog/101558 实例：http://hyxw5890.iteye.com/blog/1578597 从使用场景的角度出发来介绍对ReentrantLock的使用，相对来说容易理解一些。 可重入概念 若一个程序或子程序可以“安全的被并行执行(Parallel computing)”，则称其为可重入...
reentrantlock使用
07-12
ReentrantLock 和 Condition 在 Java 中是一种同步工具，...举个例子：如果有多个线程在等待一个特定的条件，使用 Condition 可以使一个线程等待，直到另一个线程唤醒它。这样，可以确保所有线程都按照预期的顺序执行。
ReentrantLock中Condition的wait方法、signal方法简单场景回顾
长沙要起风了、
12-16 1480
这里不讲代码，只是用图大概描述Condition在ReentrantLock中做了一件怎么样的事情。 流程描述 Lock lock = new ReentrantLock(); Condition condition = lock.newCondition(); 当多个线程开始抢占ReentrantLock的锁时 lock.lock(); ReentrantLock锁时互斥的，同一时刻只可能...
Java 锁类型 Synchronized和 ReentrantLock wait和sleep以及notify
热门推荐
emmmsuperdan的博客
08-27 1万+
线程获取锁的过程： 成功获取锁的线程，它会从等待队列中出列，并得到共享资源； 没有获取到锁的线程，继续在等待队列中，阻塞在lock方法； 线程释放锁的过程： 通过 在finally语句中的unlock方法，将锁释放，然后等待队列中的线程去竞争这个锁； 悲观锁：每次访问数据线程都是处于阻塞的状态，这样提高安全性，像读锁，写锁都是用到了悲观锁，以及...
Java线程同步与阻塞ReentrantLock - Condition替换wait - notify
Zhang Phil
07-17 640
import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; public class Main { private ReentrantLock lock = new ReentrantLock(false); private Condition con...
java并发编程（五）----（JUC）ReentrantLock
a2225791的博客
12-29 167
上一节我们了解了Lock接口的一些简单的说明，知道Lock锁的常用形式，那么这节我们正式开始进入JUC锁（java.util.concurrent包下的锁，简称JUC锁）。下面我们来看一下Lock最常用的实现类ReentrantLock。 1.Ree...
ReentrantLock
快乐的小三菊的博客
12-17 597
ReentrantLock 的语法和特性，特性包括可重入性、可打断、超时释放、公平锁、条件变量等相关知识
wait notifyAll ReentrantLock Condition 实现同步容器
qq_32555377的博客
11-12 126
wait notifyAll 实现同步容器 public class Container1<T > { final private LinkedList<T> list = new LinkedList<>(); final private int Max = 10; private int count = 0; public synchronized void put(T t){ while (list.size()
java lock await_【Java基础】synchronized与wait，notify& ReentrantLock与await，signal
weixin_35838394的博客
02-13 388
背景最近在重构证书管理的需求。之前的代码中，更新证书与吊销证书异步进行，没有进行同步控制。但是会导致主要的两个问题：1. 更新证书线程和吊销证书线程会对相同的文件进行操作。2. 不对这两个线程进行同步，日志内容交叉，不好查看。所以我使用ReentrantLock结合Condition来保证更新证书线程与吊销证书线程交替执行。synchronized & Object.wait() Obje...
【java】java wait 原理 synchronized ReentrantLock 唤醒顺序
九师兄
03-20 1389
学习一网友交流请问下，synchronized大并发的情况下，等待区的线程entrySet和waitSet里的线程分别对应Thread的哪个状态啊，都是wating吗？entryList是blocking状态吧，waitSet是waiting状态线程的生命周期，blocking和waiting不是同一种状态吗总结如下：synchronized关键字的调用wait方法进入等到的线程和因为拿不到锁而等待线程是否同一种状态？blocking？waiting？
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小鲁蛋儿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值