【并发编程】ConditionObject

lxtx-0510

于 2024-02-12 21:05:00 发布

阅读量1k

点赞数 17

分类专栏：并发编程文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_38996079/article/details/136092943

版权

本文深入探讨了Java并发编程中的ConditionObject，详细分析了它的应用、构造方式及核心属性。阐述了await和signal方法的工作原理，包括线程等待、唤醒、锁的释放与获取等关键步骤，为理解ReentrantLock的条件机制提供了全面的指导。

摘要由CSDN通过智能技术生成

1、 conditionObject 的介绍&应用

2、Condition的构建方式&核心属性

2.1 condition 中的核心属性

3、await 方法

3.1 addConditionWaiter

3.2 unlinkCancelledWaiters

3.3 fullyRelease

4、signal方法分析

4.1 doSignal

4.2 transferForSignal

5、await 再分析

5.1 await

5.2 checkInterruptWhileWaiting

5.3 transferAfterCancelledWait

5.4 isOnSyncQueue

5.5 findNodeFromTail

5.6 reportInterruptAfterWait

1、 conditionObject 的介绍&应用

ReentrantLock 提供了同synchronized（wait 和 notify）类似的功能，await及signal

想要执行await 和 signal ，必须先要有lock锁资源

public static void main(String[] args) throws InterruptedException, IOException {
    ReentrantLock lock = new ReentrantLock();
    Condition condition = lock.newCondition();

    new Thread(() -> {
        lock.lock();
        System.out.println("子线程获取锁资源并await挂起线程");
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        try {
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("子线程挂起后被唤醒！持有锁资源");

    }).start();
    Thread.sleep(100);
    // =================main======================
    lock.lock();
    System.out.println("主线程等待5s拿到锁资源，子线程执行了await方法");
    condition.signal();
    System.out.println("主线程唤醒了await挂起的子线程");
    lock.unlock();
}

2、Condition的构建方式&核心属性

发现在通过lock锁对象执行newCondition方法时，本质就是直接new的AQS提供的ConditionObject对象

final ConditionObject newCondition() {
    return new ConditionObject();
}

2.1 condition 中的核心属性

/** First node of condition queue. */
private transient Node firstWaiter;
/** Last node of condition queue. */
private transient Node lastWaiter;

虽然Node对象有prev和next，但是在ConditionObject中是不会使用这两个属性的，只要在Condition队列中，这两个属性都是null。在ConditionObject中只会使用nextWaiter的属性实现单向链表的效果。

3、await 方法

持有锁的线程在执行await方法后会做几个操作：

判断线程是否中断，如果中断了，什么都不做。
没有中断，就讲当前线程封装为Node添加到Condition的单向链表中
一次性释放掉锁资源。
如果当前线程没有在AQS队列，就正常执行LockSupport.park(this)挂起线程。

// await方法的前置分析，只分析到线程挂起
public final void await() throws InterruptedException {
    // 先判断线程的中断标记位是否是true
    if (Thread.interrupted())
        // 如果是true，就没必要执行后续操作挂起了。
        throw new InterruptedException();
    // 在线程挂起之前，先将当前线程封装为Node，并且添加到Condition队列中
    Node node = addConditionWaiter();
    // fullyRelease在释放锁资源，一次性将锁资源全部释放，并且保留重入的次数
    int savedState = fullyRelease(node);
    // 省略一行代码……
    // 当前Node是否在AQS队列中？
    // 执行fullyRelease方法后，线程就释放锁资源了，如果线程刚刚释放锁资源，其他线程就立即执行了signal方法，
    // 此时当前线程就被放到了AQS的队列中，这样一来线程就不需要执行LockSupport.park(this);去挂起线程了
    while (!isOnSyncQueue(node)) {
        // 如果没有在AQS队列中，正常在Condition单向链表里，正常挂起线程。
        LockSupport.park(this);
        // 省略部分代码……
    }
    // 省