Java中的Condition详解

一、Condition简介

任意一个Java对象,都拥有一组监视器方法(定义在Object类中),主要包括wait,notify,notifyAll方法,这些方法与synchornized关键字相配合,可以实现等待/通知模式。

Condition接口也提供了类似的Object的监视器方法,与Lock配合可以实现等待/通知模式。但是这两者在使用方式以及功能上还是有差别的。

Condition定义了等待/通知两种类型的方法,当前线程调用这些方法时,需要提前获取到Condition对象关联的锁。Condition对象是由Lock对象创建出来的,换句话说,Condition是依赖Lock对象的。

Condition在调用方法之前必须获取锁。使用方式如下图

Condition调用await方法后,当前线程会释放锁并在此等待,而其他线程调用Condition对象的singal方法,通知当前线程,当前线程才从await方法返回,并且在返回前已经获取了锁。

Contiditon定义的部分方法如下

 二、Condition的实现分析

Condition的实现,主要包括等待队列,等待和通知。

2.1、等待队列

等待队列是一个FIFO的队列,在队列中的每个节点都包含了一个线程引用,该线程就是在Condition对象上等待的线程,

如果一个线程调用了Condition.await方法,那么该线程将会释放锁,构造成节点并加入等待队列进入等待状态。

一个Condition包含一个等待队列,Condition对象拥有首节点和尾节点的引用。当前线程调用await方法,将会构造节点并加入到等待队列尾部。等待队列的基本结构如图所示。

如图所示,Condition拥有首节点和尾节点的引用,而新增节点只需要将原有的尾节点的nextWaiter指向它,并且更新尾节点即可。上述节点引用更新的过程并没有使用CAS保证,因为调用await的线程必定是获取了锁的线程,也就是说,这个过程是由锁来保证线程安全的。

在Object的监视器模型上,一个对象拥有一个同步队列和一个等待队列,而并发包中的Lock拥有一个同步队列和多个等待队列,其关系图如图所示。

如图所示,Condition的实现是同步器的内部类,因此每个Condition实例都能够访问同步器AQS提供的方法。

2.2、等待

调用Condition的await方法,会使当前线程进入等待队列并释放锁,同时线程状态变为等待状态。从await方法返回时,当前线程一定获取了Condition相关联的锁。

如果从队列(同步队列和等待队列)的角度来看await方法,调用await方法时,相当于同步队列的首节点移动到了等待队列中。

public final void await() throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    //当前线程加入等待队列
    Node node = addConditionWaiter();
    //释放同步状态,也就是释放锁
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    while (!isOnSyncQueue(node)) {
        //将当前线程阻塞
        LockSupport.park(this);
        //线程被唤醒后,查看线程是否取消或被中断,如果被取消或被中断,则跳出循环
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    //线程以独占方式获取锁
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null) // clean up if cancelled
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}

调用await方法的线程成功获取了锁,该方法会将当前线程构造成节点并加入等待队列中,然后释放同步状态,唤醒同步队列中的后继节点。

当等待队列中的节点被唤醒,则唤醒节点的线程开始尝试获取同步状态,如果不是通过其他线程调用singal方法唤醒,而是对线程进行中断,则会抛出中断异常。

同步队列的首节点不会直接加入到等待队列,而是通过addConditionWaiter方法把当前线程构造成一个新的节点并将其加入等待队列。

三、通知

通过调用Condition.singal方法,将会唤醒在等待队列中等待时间最长的节点(首节点),在唤醒节点之前,会将节点移到同步队列中。

public final void signal() {
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    //取出等待队列的首节点
    Node first = firstWaiter;
    if (first != null)
        //唤醒节点
        doSignal(first);
}
private void doSignal(Node first) {
    do {
        //首节点引用后移
        if ( (firstWaiter = first.nextWaiter) == null)
            lastWaiter = null;
        //将首节点的nextWaiter指针置空
        first.nextWaiter = null;
    } while (!transferForSignal(first) &&
            (first = firstWaiter) != null);
}
final boolean transferForSignal(Node node) {
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        return false;
    //将该节点加入同步队列尾部
    Node p = enq(node);
    int ws = p.waitStatus;
    //如果该节点处于取消或者被中断的状态,或者将该节点的状态以CAS操作设置为SINGAL失败,都会唤醒这个线程
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        LockSupport.unpark(node.thread);
    return true;
}

通过调用AQS的enq方法,等待队列的头结点线程安全的移动到同步队列。当节点移动到同步队列后,当前线程的状态如果处于取消或者被中断的状态,或者更新该节点的状态失败则会唤醒这个线程。

被唤醒后的线程将从await方法的while循环中退出(isOnSyncQueue返回true,因为节点已经在同步队列中),进而调用AQS的acquireQueued方法加入到获取同步状态的竞争中。

Condition的singalAll方法,相当于对等待队列的每个节点均执行一次singal方法,效果就是将等待队列中所有节点全部移动到同步队列,并唤醒每个节点的线程。

原文地址: Java中的Condition_yanghan1222的博客-CSDN博客_java的condition

  • 10
    点赞
  • 41
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JavaCondition是一个用于线程间通信的对象,它可以让线程在等待某个条件成立时进入等待状态,直到其他线程发出通知唤醒它。Condition通常与Lock一起使用,它提供了类似于Object.wait()和Object.notify()的功能,但是更加灵活和强大。 在使用Condition时,我们需要通过Lock对象的newCondition()方法来创建一个Condition对象,然后使用await()方法让线程进入等待状态,在条件满足时使用signal()或signalAll()方法来唤醒等待的线程。 例如,下面的代码演示了如何使用Condition来实现生产者消费者模式: ```java import java.util.LinkedList; import java.util.Queue; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class ProducerConsumerExample { private static final int CAPACITY = 5; private final Queue<Integer> queue = new LinkedList<>(); private final Lock lock = new ReentrantLock(); private final Condition notFull = lock.newCondition(); private final Condition notEmpty = lock.newCondition(); public void put(int value) throws InterruptedException { lock.lock(); try { while (queue.size() == CAPACITY) { notFull.await(); } queue.add(value); notEmpty.signal(); } finally { lock.unlock(); } } public int get() throws InterruptedException { lock.lock(); try { while (queue.isEmpty()) { notEmpty.await(); } int value = queue.poll(); notFull.signal(); return value; } finally { lock.unlock(); } } } ``` 在这个例子,我们使用了一个队列来作为缓冲区,当队列满时,生产者线程调用notFull.await()进入等待状态,直到消费者线程取走一个元素后再唤醒它;当队列空时,消费者线程调用notEmpty.await()进入等待状态,直到生产者线程放入一个元素后再唤醒它。这样就可以有效地控制生产者和消费者的速度,避免了队列溢出和下溢的情况。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值