重入锁ReentrantLock+Condition 实现等待/通知

最新推荐文章于 2025-09-12 14:47:00 发布
原创 最新推荐文章于 2025-09-12 14:47:00 发布 · 1.2k 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#多线程编程 #condition #reenstrantlock #await #signal

本文详细介绍了Java中的ReentrantLock机制，包括其实现同步的基本用法、如何与Condition结合实现等待/通知模式，以及如何利用多个Condition来精确控制线程唤醒。

        在Java多线程编程中，可以使用Synchronized来实现同步，可以synchronized类，方法或代码块，另外还可以使用ReentrantLock来实现同样的功能，而且功能更加强大。

        1. 使用ReentrantLock实现同步

public class ReentrantLockTest {

    private Lock lock = new ReentrantLock();

    public void testLock(){

        //获取锁
        lock.lock();
        try {
            for (int i = 0; i < 10; i++){
                System.out.println("Thread - " + Thread.currentThread().getName() + "===" + i);

                    Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 解锁
        lock.unlock();
    }
}
public class ReentrantLockThread extends Thread {

    private ReentrantLockTest reentrantLockTest;

    public ReentrantLockThread(ReentrantLockTest reentrantLockTest){

        super();
        this.reentrantLockTest = reentrantLockTest;
    }

    @Override
    public void run(){

        reentrantLockTest.testLock();
    }
}

public class TestLock {

    public static void main(String[] args){

        ReentrantLockTest reentrantLockTest = new ReentrantLockTest();

        Thread threadA = new ReentrantLockThread(reentrantLockTest);
        threadA.setName("A");
        Thread threadB = new ReentrantLockThread(reentrantLockTest);
        threadB.setName("B");

        threadA.start();
        threadB.start();
    }
}

运行结果

加锁结果：


未加锁结果


从运行结果可以看出，使用了ReentrantLock的lock()方法和unlock()方法后，代码也达到了同步的效果。

接下来继续验证ReentrantLock实现同步是否持有对象锁

继续给添加新的方法X和Y，然后不同的线程调用不同的方法

public class ReentrantLockTest {

    private Lock lock = new ReentrantLock();

    public void testLockX(){
        try {
            //获取锁
            lock.lock();
            System.out.println("Thread --- " + Thread.currentThread().getName() + "====Method X");
            Thread.sleep(1000);
            System.out.println("Thread --- " + Thread.currentThread().getName() + "====Method X");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
        }
    }

    public void testLockY(){
        try {
            //获取锁
            lock.lock();
            System.out.println("Thread --- " + Thread.currentThread().getName() + "====Method Y");
            Thread.sleep(1000);
            System.out.println("Thread --- " + Thread.currentThread().getName() + "====Method Y");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 解锁
            lock.unlock();
        }
    }
}

调用X方法的线程、

public class ReentrantLockThreadX extends Thread {

    private ReentrantLockTest reentrantLockTest;

    public ReentrantLockThreadX(ReentrantLockTest reentrantLockTest){

        super();
        this.reentrantLockTest = reentrantLockTest;
    }

    @Override
    public void run(){

        reentrantLockTest.testLockX();
    }
}

调用Y方法的线程

public class ReentrantLockThreadY extends Thread{

    private ReentrantLockTest reentrantLockTest;

    public ReentrantLockThreadY(ReentrantLockTest reentrantLockTest){

        super();
        this.reentrantLockTest = reentrantLockTest;
    }

    @Override
    public void run(){

        reentrantLockTest.testLockY();
    }
}

测试类

public class TestLock {

    public static void main(String[] args){

        ReentrantLockTest reentrantLockTest = new ReentrantLockTest();

        Thread threadA = new ReentrantLockThreadX(reentrantLockTest);
        threadA.setName("A");
        Thread threadB = new ReentrantLockThreadX(reentrantLockTest);
        threadB.setName("B");

        Thread threadC = new ReentrantLockThreadY(reentrantLockTest);
        threadC.setName("C");
        Thread threadD = new ReentrantLockThreadY(reentrantLockTest);
        threadD.setName("D");

        threadA.start();
        threadB.start();
        threadC.start();
        threadD.start();
    }
}

运行结果


从结果可以看出，ReentrantLock获取的是对象锁，即持有“对象监听器”，当某线程持有了对象锁后，其他的线程只能等待锁释放是争抢锁。线程执行的顺序是随机的。

        2. 使用ReentrantLock和Condition实现等待/通知

Synchronized和wait()+notify()/notifyAll()可以实现等待/通知模式，那么ReentrantLock怎样实现呢？

ReentrantLock可以和Condition对象可以实现等待/通知的效果

下面通过代码看效果

public class LockAndCondition {

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void mockWait(){

        try {
            // 加锁
            lock.lock();
            System.out.println("已经加锁");
            condition.await();
            System.out.println("已经await");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放锁
            lock.unlock();
            System.out.println("已经释放锁");
        }
    }
}
public class TestLockAndCondition {

    public static void main(String[] args){

        LockAndCondition lockAndCondition = new LockAndCondition();
        Thread thread = new LockAndConditionThread(lockAndCondition);
        thread.start();
    }
}
public class LockAndConditionThread extends Thread {

    private LockAndCondition lockAndCondition;

    public LockAndConditionThread(LockAndCondition lockAndCondition){

        super();
        this.lockAndCondition = lockAndCondition;
    }

    @Override
    public void run(){

        lockAndCondition.mockWait();
    }
}

运行结果


从运行的结果我们可以看出，代码执行到“已经加锁”的下面await方法处，线程处于等待状态了没有继续向下执行，接下来我们继续测试唤醒该线程

package thread.reentrantlock;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class LockAndCondition {

    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    public void mockWait(){

        try {
            // 加锁
            lock.lock();
            System.out.println("In mockWait 已经加锁");
            condition.await();
            System.out.println("已经await");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放锁
            lock.unlock();
            System.out.println("In mockWait 已经释放锁");
        }
    }

    /**
     * 新加唤醒方法
     */
    public void mockNotify(){

        try {
            // 加锁
            lock.lock();
            System.out.println("In mockNotify 已经加锁");
            condition.signal();
            System.out.println("已经signal");
        } finally {
            // 释放锁
            lock.unlock();
            System.out.println("In mockNotify 已经释放锁");
        }
    }
}

测试类

public class TestLockAndCondition {

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

        LockAndCondition lockAndCondition = new LockAndCondition();
        Thread thread = new LockAndConditionThread(lockAndCondition);
        thread.start();
        lockAndCondition.mockNotify();
    }
}

运行结果


通过condition的signle()方法唤醒等待线程。

同样的，condition也有方法可以唤醒全部等待线程，使用signalAll()方法，而且，condition有更加强大的用户，就是唤醒指定线程。下面继续测试。

        3. 使用多个condition唤醒指定线程

        首先，定义多个condition

package thread.reentrantlock;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MoreCondition {

    private Lock lock = new ReentrantLock();
    private Condition conditionA = lock.newCondition();
    private Condition conditionB = lock.newCondition();

    public void testMoreConditionAwaitA(){

        try{
            lock.lock();
            System.out.println("Thread --- " + Thread.currentThread().getName() + "Method --- A --- Lock");
            conditionA.await();
            System.out.println("Thread --- " + Thread.currentThread().getName() + "Method --- A --- 被唤醒");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void testMoreConditionSignalAllA(){

        try {
            lock.lock();
            //唤醒所有使用conditionA等待的线程
            conditionA.signalAll();
            System.out.println("Thread --- " + Thread.currentThread().getName() + "Method --- A --- SignalAll");
        } finally {
            lock.unlock();
        }
    }

    public void testMoreConditionAwaitB(){

        try{
            lock.lock();
            System.out.println("Thread --- " + Thread.currentThread().getName() + "Method --- B --- Lock");
            conditionB.await();
            System.out.println("Thread --- " + Thread.currentThread().getName() + "Method --- B --- 被唤醒");
        } catch (InterruptedException e){
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }

    public void testMoreConditionSignalAllB(){

        try {
            lock.lock();
            conditionB.signalAll();
            System.out.println("Thread --- " + Thread.currentThread().getName() + "Method --- B --- SignalAll");
        } finally {
            lock.unlock();
        }
    }
}

调用A方法的线程

package thread.reentrantlock;

public class MoreConditionThreadA extends Thread{

    private MoreCondition moreCondition;

    public MoreConditionThreadA(MoreCondition moreCondition){

        super();
        this.moreCondition = moreCondition;
    }

    @Override
    public void run(){
        moreCondition.testMoreConditionAwaitA();
    }
}

调用B方法的线程

package thread.reentrantlock;

public class MoreConditionThreadB extends Thread {

    private MoreCondition moreCondition;

    public MoreConditionThreadB(MoreCondition moreCondition){

        super();
        this.moreCondition = moreCondition;
    }

    @Override
    public void run(){

        this.moreCondition.testMoreConditionAwaitB();
    }
}

测试类

package thread.reentrantlock;

public class MoreConditionTest {

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

        MoreCondition moreCondition = new MoreCondition();

        Thread threadA1 = new MoreConditionThreadA(moreCondition);
        Thread threadA2 = new MoreConditionThreadA(moreCondition);
        Thread threadA3 = new MoreConditionThreadA(moreCondition);
        Thread threadB1 = new MoreConditionThreadB(moreCondition);
        Thread threadB2 = new MoreConditionThreadB(moreCondition);
        Thread threadB3 = new MoreConditionThreadB(moreCondition);

        threadA1.setName("A1");
        threadA2.setName("A2");
        threadA3.setName("A3");
        threadB1.setName("B1");
        threadB2.setName("B2");
        threadB3.setName("B3");

        threadA1.start();
        threadA2.start();
        threadA3.start();

        threadB1.start();
        threadB2.start();
        threadB3.start();

        Thread.sleep(2000);
        // 唤醒A线程
        moreCondition.testMoreConditionSignalAllA();
        // 唤醒B线程
//        moreCondition.testMoreConditionSignalAllB();
    }
}

运行结果


所有调用A方法的线程全部别唤醒，调用B方法的线程依然在等待。

通过这个例子可以看出，使用condition+signal/signalAll方法可以唤醒指定的线程

JAVA 并发编程之七：重入锁ReentrantLock + lock + condition ：可选择唤醒特定线程（线程状态控制Type2）
caobaokang的专栏
04-09 522
前言：synchronized和ReentrantLock的区别： 1. 要注意synchronized同步，假如发生异常，JVM是可以帮我们自动释放锁的；但是lock不可以，我们只能手动释放锁，即使发生异常，jvm也不会自动释放锁。 2.synchronized与wait()和notify()/notifyAll()方法结合可以实现等待通知模式；Reentrantlock可以实现同样的功能...
可重入锁ReentrantLock的原理及使用
apple_51673523的博客
08-09 1910
在公平模式下，锁会按照线程的请求顺序分配，遵循先进先出的原则。构造方法接受一个可选的公平参数（默认非公平锁），当设置为true时，表示公平锁，否则为非公平锁。公平锁的效率往往没有非公平锁的效率高，在许多线程访问的情况下，公平锁表现出较低的吞吐量。ReentrantLock是一个强大而灵活的同步工具，它提供了更多的控制选项和功能，适用于各种复杂的同步需求。方法，它可以尝试获取锁，如果锁当前不可用，则立即返回结果。，因此在使用时需要谨慎，并确保正确处理锁的获取和释放，以避免死锁和其他并发问题。
ReentrantLock绑定多个Condition（代码实现）
gaopan1999的博客
03-21 1851
多线程按顺序调用 , A->B->C A打印5次，B打印10次，C打印15次 class ShareResource { private int number = 1; //A :1 B:2 C:3 private Lock lock = new ReentrantLock(); private Condition c1 =lock.newCondition(); p...
并发编程学习之二：重入锁 ReentrantLock 的使用之限时等待
liuying1802028915的博客
05-20 467
并发编程学习之一：重入锁 ReentrantLock 的使用 下面直接给出案例： public class TimeLock implements Runnable { public static ReentrantLock lock = new ReentrantLock(); private static final int NUM = 5; @Override public void run() { try { if
最常用的锁：ReentrantLock可重入锁
最新发布
2401_85973273的博客
09-12 1410
本文系统解析了Java并发编程中的ReentrantLock同步工具。作为synchronized的增强替代方案，ReentrantLock通过AQS实现，具备可重入性、可中断锁获取、公平/非公平模式选择及多条件变量等核心特性。文章详细对比了其与synchronized的差异，包括灵活性、性能表现和使用复杂度，并给出标准使用流程（必须在try-finally中确保锁释放）和典型应用场景（如生产者-消费者模型）。最后指出应基于具体需求在易用性（synchronized）与高级功能（ReentrantLock）
线程安全（七）ReentrantLock 简介、Condition 条件变量、锁的工作原理、synchronized 与 Lock 的区别
ACGkaka的博客
07-17 1476
线程安全（七）ReentrantLock 简介、Condition 条件变量、锁的工作原理、synchronized 与 Lock 的区别
Java多线程11：ReentrantLock的使用和Condition
weixin_34384557的博客
10-04 485
ReentrantLock ReentrantLock，一个可重入的互斥锁，它具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。   ReentrantLock基本用法 先来看一下ReentrantLock的基本用法： public class ThreadDomain38 { private Lock lock = ...
ReentrantLock 锁与唤醒锁
Little_bear_mountain的博客
03-30 419
public class UseManyCondition {     private ReentrantLock lock = new ReentrantLock();     private Condition c1 = lock.newCondition();     private Condition c2 = lock.newCondition();          pu
java 线程锁 可重入锁 可中断锁 公平锁 非公平锁ReentrantLock synchronized,条件Condition,读写锁 ReentrantReadWriteLock写写互斥读读共享
银河系天城知识宝库_技术专家蒋浩宇
05-06 538
目录 介绍 synchronized 修饰方块执行顺序 lock 提供了更加灵活的方式实现 lock 接口 这玩意应用场景 加锁和释放锁示例 lock普通获取锁 tryLock() 中断锁 newCondition() Lock接口的实现类：可重入锁 ReentrantLock 主要方法 ReentrantLock 锁示例 lock示例 结果日志 tryLock 锁 结果 lock.tryLock(1000,TimeUnit.SECONDS) lockInterrupt.
深入解析JUC线程间通信：使用ReentrantLock与Condition实现精准线程调度
weixin_62938484的博客
08-21 535
本文探讨了使用JUC包中的ReentrantLock和Condition实现精细化线程通信的方法。相比传统synchronized结合wait/notifyAll的方式，新方法通过Condition实现精准唤醒特定线程，避免了不必要的线程竞争。文章详细解析了共享资源类设计、线程执行控制等关键实现，并总结了while循环检查条件、确保锁释放等最佳实践。该模式适用于多阶段任务、生产者-消费者等场景，能显著提升多线程程序的性能和可维护性。
ReentrantLock等待通知机制Condition介绍
weixin_30470643的博客
02-16 239
　　Object类中的wait()，notify()和notifyAll()可以实现线程的等待通知模型，同样在ReentrantLock中可以借助Condition来完成这种机制。本篇就简要介绍Condition的工作原理。 　　先看一下Condition的使用示例： public class LockConditionTest { private ReentrantLock l...
ReentrantLock处理简单的等待返回场景
cherises的博客
08-16 231
这几天遇到了一个稍显特殊的场景,大概如下 基于综合考虑,
ReentrantLock类与Condition类配合实现等待/通知机制
飞翔的宇宙
07-04 1218
一.ReentrantLock概述:      ReentrantLock和synchronized一样效果，都可以同步执行，ReentrantLock通过lock方法获得锁，unlock方法释放锁。 二.ReentrantLock常用方法： lock()： 获取锁，调用该方法当前线程将会获取锁，当锁获取后，该方法将返回，否则阻塞。 lockInt...
ReentrantLock（二）：正确使用Condition实现等待与通知
三叶初秋的博客
04-26 8721
关键字synchronized与wait()和notify()/notifyAll()方法相结合可以实现等待/通知模式。 类ReentrantLock同样可以实现该功能，但是要借助于Condition对象。它具有更好的灵活性，比如可以实现多路通知功能，也就是在一个Lock对象里面可以创建多个Condition(对象监视器)实例，线程对象可以注册在指定Condition中，从而有选择性的进行线程通知
ReentrantLock及Condition
有个疙叫瘩儿的博客
12-14 1073
ReentrantLock ReentrantLock，一个可重入的互斥锁，它具有与使用synchronized方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但功能更强大。 Condition介绍 Condition是一个多线程间协调通信的工具类，使得某个或者某些线程一起等待某个条件（Condition）,只有当该条件具备( signal 或者 signalAll方法被带调用)时 ，这些等待线程才会被唤醒，从而重新争夺锁。 ...
Lock的使用：Condition实现等待/通知
张震震不会讲Gui故事的博客
04-22 233
关键字synchronized与wait（）和notify（）/notify()方法结合可以实现等待/通知模式，当然ReentrantLock可以实现这样的功能，只不过需要借助一个叫Condition的对象。Condition对象会有着更好的灵活性，比如实现多路通知，也就是在一个Lock对象里面创建多个Condition实例，线程对象可以注册在一个指定的Condition中，从而可以进行有选择的通...
ReentrantLock和Condition
林竹清_清清清
03-29 969
1.ReentrantLock： jdk1.5中的ReentrantLock类也能达到同步的效果，并且相比于synchronized功能更强大，比如具有嗅探锁定、多路分支通知。ReentrantLock 将由最近成功获得锁，并且还没有释放该锁的线程所拥有。当锁没有被另一个线程所拥有时，调用 lock 的线程将成功获取该锁并返回。如果当前线程已经拥有该锁，此方法将立即返回。可以使用 is
ReentrantLockCondition锁与Synchronized在多线程中的使用
zpflwy1314的博客
12-04 302
生产者-消费者（producer-consumer）问题，也称作有界缓冲区（bounded-buffer）问题，两个进程共享一个公共的固定大小的缓冲区。其中一个是生产者，用于将消息放入缓冲区；另外一个是消费者，用于从缓冲区中取出消息。 问题出现在当缓冲区已经满了，而此时生产者还想向其中放入一个新的数据项的情形，其解决方法是让生产者此时进行休眠，等待消费者从缓冲区中取走了一个或者多个数据后再...
ReentrantLock 搭配 Condition 类实现等待-唤醒
10-16
ReentrantLock 是 Java 中的一个互斥锁实现，它提供了一种比 synchronized 关键字更细粒度的控制以及中断、公平锁等特性。当多个线程需要等待特定条件满足后再继续执行时，可以结合 ReentrantLock 和 Condition 类...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值