【Java并发编程】Condition详解

已于 2024-10-17 09:44:26 修改
阅读量1.8k 收藏 22
点赞数 9
分类专栏： Java多线程 文章标签： java 开发语言 后端
于 2024-10-10 17:07:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/w1475995549/article/details/142820699
版权

一、简介

1.1 什么是Condition

任意一个Java对象，都拥有一组监视器方法（定义在java.lang.Object上），主要包括 wait()、wait(long timeout)、notify() 以及 notifyAll() 方法，这些方法与 synchronized 同步关键字配合，可以实现等待/通知模式。Condition接口也提供了类似Object的监视器方法，与Lock配合可以实现等待/通知模式，但是这两者在使用方式以及功能特性上还是有差别的。——摘自《Java并发编程的艺术》

下面是Condition与Object的监视器方法的对比（摘自《Java并发编程的艺术》）：

1.2 Condition接口

我们来看一下Condition接口的定义：

public interface Condition {

    //等待，当前线程接受到信号前、或中断前一直处于等待状态
    void await() throws InterruptedException;

    //等待，当前线程接受到信号前一直处于等待状态，不响应中断
    void awaitUninterruptibly();

    //等待，当前线程接受到信号前、或中断前、或到达指定等待时间之前一直处于等待状态，返回值 = nanosTimeout - 实际消耗的时间，返回值 <= 0表示超时
    long awaitNanos(long nanosTimeout) throws InterruptedException;

    //等待，当前线程接受到信号前、或中断前、或到达指定等待时间之前一直处于等待状态，返回boolean类型，表示是否在指定时间内获取到接受信号，false表示超时。
    //它与上一个方法不同在于可以自定义超时时间单位，等同于awaitNanos(unit.toNanos(time)) > 0
    boolean await(long time, TimeUnit unit) throws InterruptedException;

    //等待，当前线程在接收到信号前、被中断或到达指定最后唤醒一个等待线程。如果所有的线程都在等待此条件，则选择其中的一个唤醒。在从 await 返回之前，该线程必须重新获取锁。期限之前一直处于等待状态
    boolean awaitUntil(Date deadline) throws InterruptedException;

    //唤醒一个等待线程。如果所有的线程都在等待此条件，则选择其中的一个唤醒。在从 await 返回之前，该线程必须重新获取与Condition相关的锁。
    void signal();

    //唤醒所有等待线程。如果所有的线程都在等待此条件，则唤醒所有线程。在从 await 返回之前，每个线程都必须重新获取与Condition相关的锁。
    void signalAll();
}

        Condition 是一种广义上的条件队列。他为线程提供了一种更为灵活的等待/通知模式，线程在调用 await() 方法后执行挂起操作，直到线程等待的某个条件为真时才会被唤醒。Condition 必须要配合锁一起使用，因为对共享状态变量的访问发生在多线程环境下。一个 Condition 的实例必须与一个Lock绑定，因此Condition一般都是作为Lock的内部实现。

二、基本使用

以基本的B线程唤醒A线程为例：

2.1 Object#wait/notify 等待唤醒写法

public static void main(String[] args) throws InterruptedException {
    //对象锁
    Object obj=new Object();

    //创建线程A
    Thread threadA = new Thread(()->{
        System.out.println("A尝试获取锁...");
        synchronized (obj){
            System.out.println("A获取锁成功！");
            try {
                TimeUnit.SECONDS.sleep(1);
                System.out.println("A开始释放锁，并开始等待...");
                //线程A开始等待
                obj.wait();
                System.out.println("A被通知继续运行，直至结束。");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    });
    //创建线程B
    Thread threadB = new Thread(()->{
        System.out.println("B尝试获取锁...");
        synchronized (obj){
            System.out.println("B获取锁成功！");
            try {
                TimeUnit.SECONDS.sleep(3);
                //线程B开始唤醒线程A
                obj.notify();
                System.out.println("B随机通知lock对象的等待队列中某个线程！");
                System.out.println("B执行完毕，开始释放锁...");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    });
    //启动线程A
    threadA.start();
    //这里为了是线程A先执行，避免B先执行了notify导致A永远无法被唤醒
    TimeUnit.SECONDS.sleep(1);
    //启动线程B
    threadB.start();
}

//执行结果
A尝试获取锁...
A获取锁成功！
A开始释放锁，并开始等待...
B尝试获取锁...
B获取锁成功！
B随机通知lock对象的等待队列中某个线程！
B执行完毕，开始释放锁...
A被通知继续运行，直至结束。

2.2 Condition#await/signal 等待唤醒写法

public static void main(String[] args) throws InterruptedException {
    //创建lock对象
    Lock lock = new ReentrantLock();
    //新建condition
    Condition condition = lock.newCondition();

    //创建线程A
    Thread threadA = new Thread(()->{
        System.out.println("A尝试获取锁...");
        lock.lock();
        try {
            System.out.println("A获取锁成功！");
            TimeUnit.SECONDS.sleep(1);
            System.out.println("A开始释放锁，并开始等待...");
            //线程A开始等待
            condition.await();
            System.out.println("A被通知继续运行...");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
            System.out.println("A线程释放了锁，执行结束！");
        }

    });
    //创建线程B
    Thread threadB = new Thread(()->{
        System.out.println("B尝试获取锁...");
        lock.lock();
        try {
            System.out.println("B获取锁成功！");
            TimeUnit.SECONDS.sleep(3);
            //线程B开始唤醒线程A
            condition.signal();
            System.out.println("B随机通知lock对象的等待队列中某个线程！");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.unlock();
            System.out.println("B线程释放了锁，执行结束！");
        }
    });
    //启动线程A
    threadA.start();
    //这里为了是线程A先执行，避免B先执行了notify导致A永远无法被唤醒
    TimeUnit.SECONDS.sleep(1);
    //启动线程B
    threadB.start();
}

//执行结果
A尝试获取锁...
A获取锁成功！
A开始释放锁，并开始等待...
B尝试获取锁...
B获取锁成功！
B随机通知lock对象的等待队列中某个线程！
B线程释放了锁，执行结束！
A被通知继续运行...
A线程释放了锁，执行结束！

三、源码解析

3.1 ConditionObject类

ConditionObject 是 Condition 在java并发中的具体的实现，由于Condition的操作需要获取相关的锁，而AQS则是同步锁的实现基础，所以ConditionObject则定义为AQS的内部类。每个Condition对象都对应一个等待队列。ConditionObject定义如下：

// AbstractQueuedSynchronizer
public class ConditionObject implements Condition, java.io.Serializable {
    //序列化版本号
    private static final long serialVersionUID = 1173984872572414699L;
    
    //条件（等待）队列的第一个节点
    private transient Node firstWaiter;
    
    //条件（等待）队列的最后一个节点
    private transient Node lastWaiter;
    
    //。。。。。。
}

3.1.1 等待队列

每个 ConditionObject 都包含一个FIFO队列，队列中的节点类型是AQS的内部类——Node类，每个节点包含着一个线程引用，该线程就是在该Condition对象上等待的线程。与CLH同步队列不同的是，Condition的等待队列是单向队列，即每个节点仅包含指向下一节点的引用，如下图所示：

3.1.2 ConditionObject#await() 方法解析

调用 Condition#await() 方法会使当前线程进入等待状态，同时会加入到Condition等待队列同时释放锁。await() 方法代码如下：

// AbstractQueuedSynchronizer#ConditionObject
public final void await() throws InterruptedException {
    //响应中断
    if (Thread.interrupted())
        throw new InterruptedException();
    //将当前线程加入到等待队列中---------（1）
    Node node = addConditionWaiter();
    //释放当前线程持有的锁锁资源，不管当前线程重入多少次，全部置0---------（2）
    int savedState = fullyRelease(node);
    //中断模式
    int interruptMode = 0;
    //判断节点是否在同步队列(SyncQueue)中,即是否被唤醒---------（3）
    while (!isOnSyncQueue(node)) {
        //如果不在同步队列，则在JVM级别挂起当前线程
        LockSupport.park(this);
        //线程被唤醒后，检查是否发生了中断---------（4）
        //	被唤醒有两种原因：1是发生了中断，2是别的线程调用了signal
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;  //如果发现线程已经中断了，则直接退出循环
    }
    //被唤醒后执行自旋操作尝试获取锁，同时判断线程是否被中断
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        //获取锁成功，则标记线程需要重新设置中断标记位
        interruptMode = REINTERRUPT; 
    //取消后进行清理
    if (node.nextWaiter != null) // clean up if cancelled
        //清理等待队列中不为CONDITION状态的节点
        unlinkCancelledWaiters();---------（5）
    if (interruptMode != 0)
        //根据中断模式处理中断---------（6）
        reportInterruptAfterWait(interruptMode);
}

从如上代码观察中，不难发现，await() 主要做了四件事：

  1. 调用 addConditionWaiter() 方法构建新的节点封装线程信息并将其加入等待队列。
  2. 调用 fullyRelease(node) 释放锁资源(不管此时持有锁的线程重入多少次都一律将state置0)，同时唤醒同步队列中后继节点的线程。
  3. 调用 isOnSyncQueue(node) 判断节点是否存在同步队列中，在这里是一个自旋操作，如果同步队列中不存在当前节点则直接在JVM级别挂起当前线程。
  4. 当前节点线程被唤醒后，即节点从等待队列转入同步队列时，则调用 acquireQueued(node, savedState) 方法执行自旋操作尝试重新获取锁资源。

注释标记了6个重点方法，分别来看看：

（1）addConditionWaiter() 方法：将线程封装为节点，加入到等待队列

如果没有中断异常抛出，则调用 addConditionWaiter() 方法将当前线程加入到等待队列中，方法如下：

// AbstractQueuedSynchronizer#ConditionObject
private Node addConditionWaiter() {
    //获取尾结点
    Node t = lastWaiter;
    //如果t不为空且其等待状态不为CONDITION，表示该节点不处于等待状态，需要清除掉
    if (t != null && t.waitStatus != Node.CONDITION) {
        //清理等待队列中不为CONDITION状态的节点
        unlinkCancelledWaiters();
        //重新获取新的尾结点
        t = lastWaiter;
    }
    //创建包含当前线程的结点，状态为CONDITION
    Node node = new Node(Thread.currentThread(), Node.CONDITION);
    //如果t为空，则表示队列为空，因此新节点为第一个节点
    if (t == null)
        //设置头结点
        firstWaiter = node;
    //否则队列不为空，将节点插入到最后一个位置
    else
        //节点插入到最后一个位置
        t.nextWaiter = node;
    //设置尾结点
    lastWaiter = node;
    //返回节点
    return node;
}

//清除条件队列中所有状态不为Condition的节点
private void unlinkCancelledWaiters() {
    //获取头结点
    Node t = firstWaiter;
    Node trail = null;
    //从头往尾清除掉等待状态不为CONDITION的节点
    while (t != null) {
        Node next = t.nextWaiter;
        if (t.waitStatus != Node.CONDITION) {
            t.nextWaiter = null;
            if (trail == null)
                firstWaiter = next;
            else
                trail.nextWaiter = next;
            if (next == null)
                lastWaiter = trail;
        }
        else
            trail = t;
        t = next;
    }
}

（2）fullyRelease() 方法：完全释放锁

当前节点添加到等待队列成功后，会进行调用 fullyRelease() 方法完全释放锁。代码如下：

// AbstractQueuedSynchronizer#ConditionObject
final int fullyRelease(Node node) {
    //是否失败标志
    boolean failed = true;
    try {
        //获取同步状态
        int savedState = getState();
        //释放同步状态
        if (release(savedState)) {
            //失败标志为否
            failed = false;
            //返回原同步状态
            return savedState;
        }  
        //如果释放锁失败，直接抛出异常
        else {
            throw new IllegalMonitorStateException();
        }
    } finally {
        //如果操作失败，则将节点状态置为无效
        if (failed)
            node.waitStatus = Node.CANCELLED;
    }
}

（3）isOnSyncQueue() 方法：检测此节点是否在同步队列中

如果不在，说明该线程还不具备竞争锁的资格，挂起线程继续等待，代码如下：

// AbstractQueuedSynchronizer#ConditionObject
public final void await() throws InterruptedException {
    //......
    
    //自旋检测此节点是否在同步队列中，如果不在，说明该线程还不具备竞争锁的资格，挂起线程继续等待
    while (!isOnSyncQueue(node)) {
        //挂起线程
        LockSupport.park(this);
        //线程被唤醒后，检查是否发生了中断
        //	被唤醒有两种原因：1是发生了中断，2是别的线程调用了signal
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;  //如果发现线程已经中断了，则直接退出循环
    }
    
    //......
}

我们来看一下 isOnSyncQueue() 方法的实现：

// AbstractQueuedSynchronizer#ConditionObject
//检测此节点是否在同步队列
final boolean isOnSyncQueue(Node node) {
    //若是当前节点状态为CONDITION 或者说node前驱节点为null，说明节点不在同步队列里
    if (node.waitStatus == Node.CONDITION || node.prev == null)
        return false;
    //节点状态不为CONDITION 且node前驱节点存在，并且后继节点存在，则认为在同步队列里
    //这是为什么呢？因为调用该方法之前node节点插入的位置是等待队列的末尾，next域肯定为null，如果不为空，说明肯定不在等待队列中，即在CLH队列中
    if (node.next != null) // If has successor, it must be on queue
        return true;
    //从尾往头查找CLH队列，看是否存在node节点
    //后继节点不存在，可能是节点加入到同步队列尾部的时候，CAS修改tail指向不成功，因此此处再遍历同步队列直接比较节点是否相等
    return findNodeFromTail(node);
}

//判断CLH同步队列否存在node节点
private boolean findNodeFromTail(Node node) {
    //获取节点
    Node t = tail;
    //从后往前遍历查找是否存在node节点
    for (;;) {
        if (t == node)
            return true;
        if (t == null)
            return false;
        t = t.prev;
    }
}

（4）checkInterruptWhileWaiting() 方法：返回是否发生过中断以及中断的模式

// AbstractQueuedSynchronizer#ConditionObject
//返回是否发生过中断以及中断的模式: 如果在signal之前中断，则返回THROW_IE；如果在signal之后中断，则返回REINTERRUPT；如果没有中断，则为0。
private int checkInterruptWhileWaiting(Node node) {
    //如果发生线程被中断，执行方法transferAfterCancelledWait，否则返回0
    return Thread.interrupted() ?
        (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
    0;
}
//transferAfterCancelledWait(xx)返回true，表示需要抛出中断异常，返回false，表示只需要将中断标记位补上就好了
final boolean transferAfterCancelledWait(Node node) {
    //走到这，说明线程曾经被中断过，接下来就是要判断signal动作是否发生了
    //尝试修改节点状态
    if (compareAndSetWaitStatus(node, Node.CONDITION, 0)) {
        //成功，则加入到同步队列里
            //CAS 成功表明此时还没有发生signal()
        enq(node);
        return true;
    }
    //说明CAS失败，失败的原因是：signal()里已经将node状态改变了。
        //因此，此处只需要等待signal()将节点加入到同步队列即可。
    while (!isOnSyncQueue(node))
        Thread.yield();
    return false;
}

（5）unlinkCancelledWaiters() 方法：从等待队列里移除被取消的节点

虽然前面已经将节点加入到同步队列里，但是可能并没有将节点从等待队列里移除(没有调用signal的情况)，因此这里需要检测一下。

// AbstractQueuedSynchronizer#ConditionObject
//清除条件队列中所有状态不为Condition的节点
private void unlinkCancelledWaiters() {
    //获取头结点
    Node t = firstWaiter;
    Node trail = null;
    //从头往尾清除掉等待状态不为CONDITION的节点
    while (t != null) {
        Node next = t.nextWaiter;
        if (t.waitStatus != Node.CONDITION) {
            t.nextWaiter = null;
            if (trail == null)
                firstWaiter = next;
            else
                trail.nextWaiter = next;
            if (next == null)
                lastWaiter = trail;
        }
        else
            trail = t;
        t = next;
    }
}

（6）reportInterruptAfterWait() 方法：根据中断模式处理

中断模式 interruptMode == THROW_IE，表示需要抛出中断异常；interruptMode == REINTERRUPT，表示只需要将中断标记位补上。

// AbstractQueuedSynchronizer#ConditionObject
private void reportInterruptAfterWait(int interruptMode)
    throws InterruptedException {
    //直接抛出异常，发生了中断，但是还没有signal
    if (interruptMode == THROW_IE)
        throw new InterruptedException();
    else if (interruptMode == REINTERRUPT)
        //将中断标记位补上
        selfInterrupt();
}

3.1.3 ConditionObject#signal() 方法解析 

// AbstractQueuedSynchronizer#ConditionObject
public final void signal() {
     // 判断当前线程是否持有独占锁资源，如果未持有则直接抛出异常
    if (!isHeldExclusively())
          throw new IllegalMonitorStateException();
      Node first = firstWaiter;
      // 唤醒等待队列第一个节点的线程
      if (first != null)
          doSignal(first);
}

在这里，singal() 唤醒方法一共做了两件事：

  1. 判断当前线程是否持有独占锁资源，如果调用唤醒方法的线程未持有锁资源则直接抛出异常（共享模式下没有等待队列，所以无法使用Condition）。
  2. 唤醒等待队列中的第一个节点的线程，即调用doSignal(first)方法。

我们来看看 doSignal(first) 方法的实现：

// AbstractQueuedSynchronizer#ConditionObject
private void doSignal(Node first) {
    do {
        // 移除等待队列中的第一个节点，如果nextWaiter为空
        // 则代表着等待队列中不存在其他节点，那么将尾节点也置空
        if ( (firstWaiter = first.nextWaiter) == null)
            lastWaiter = null;
        first.nextWaiter = null;
    // 如果被通知上个唤醒的节点没有进入同步队列（可能出现被中断的情况），
    // 等待队列中还存在其他节点则继续循环唤醒后继节点的线程
    } while (!transferForSignal(first) &&
             (first = firstWaiter) != null);
}

// transferForSignal()方法
final boolean transferForSignal(Node node) {
    /*
     * 尝试修改被唤醒节点的waitStatus为0即初始化状态
     *      如果设置失败则代表着当前节点的状态不为CONDITION等待状态，
     *      而是结束状态了则返回false返回doSignal()继续唤醒后继节点
     *  为什么说设置失败则代表着节点不为CONDITION等待状态？
     *      因为可以执行到此处的线程必定是持有独占锁资源的，
     *      而此处使用的是cas机制修改waitStatus，失败的原因只有一种：
     *          预期值waitStatus不等于CONDITION
     */
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        return false;
    // 快速追加到同步队列尾部，同时返回前驱节点p
    Node p = enq(node);
    // 判断前驱节点状态是否为结束状态或者在设置前驱节点状态为SIGNAL失败时，
    // 唤醒被通知节点内的线程
    int ws = p.waitStatus;
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        // 唤醒node节点内的线程
        LockSupport.unpark(node.thread);
    return true;
}

在如上代码中，可以通过我的注释发现，doSignal() 也只做了三件事：

  1. 将被唤醒的第一个节点从等待队列中移除，然后再维护等待队列中 firstWaiter 和 lastWaiter 的指向节点引用。
  2. 将等待队列中移除的节点追加到同步队列尾部，如果同步队列追加失败或者等待队列中还存在其他节点的话，则继续循环唤醒其他节点的线程。
  3. 加入同步队列成功后，如果前驱节点状态已经为结束状态或者在设置前驱节点状态为 SIGNAL 失败时，直接通过 LockSupport.unpark() 唤醒节点内的线程。

至此，signal() 方法逻辑结束，不过需要注意的是：我们在理解 Condition 的等待/唤醒原理的时候需要将 await()/signal() 方法结合起来理解。在 signal() 逻辑完成后，被唤醒的线程则会从前面的 await() 方法的自旋中退出，因为当前线程所在的节点已经被移入同步队列，所以 while (!isOnSyncQueue(node)) 条件不成立，循环自然则终止，进而被唤醒的线程会调用 acquireQueued() 开始尝试获取锁资源。

3.2 Condition接口与Monitor对象等待/唤醒机制的区别

Java并发Condition 详解
大乐乐
01-12 1354
Condition接口在Java并发编程中的重要性和优势。它提供了更为灵活和强大的等待/通知机制，支持多条件同步、可中断等待和定时等待等高级特性。在使用Condition时，我们需要注意一些常见问题，以确保程序的正确性和性能。
【Java并发编程】详解Condition的await和signal等待通知机制~
小斜同学的博客
01-21 2087
任意一个Java对象，都拥有一组监视器方法（定义在java.lang.Object上），主要包括 wait()、wait(long timeout)、notify() 以及 notifyAll() 方法，这些方法与 synchronized 同步关键字配合，可以实现等待/通知模式。Condition接口也提供了类似Object的监视器方法，与Lock配合可以实现等待/通知模式，但是这两者在使用方式以及功能特性上还是有差别的。——摘自《Java并发编程的艺术》
Java并发之Condition详解
weixin_41951205的博客
03-05 1265
一、简介 1. 什么是Condition 任意一个Java对象，都拥有一组监视器方法（定义在java.lang.Object上），主要包括wait()、wait(long timeout)、notify()以及notifyAll()方法，这些方法与synchronized同步关键字配合，可以实现等待/通知模式。Condition接口也提供了类似Object的监视器方法，与Lock配合可以实现等待/通知模式，但是这两者在使用方式以及功能特性上还是有差别的。——摘自《Java并发编程的艺术》 下面是Cond
Java中Lock和Condition用法详解
最新发布
z17826856787的博客
03-20 973
Lock提供了比更灵活的锁机制，支持尝试获取锁、超时获取锁、可中断获取锁等操作。是Lock接口的一个实现类，支持可重入锁。tryLock()和方法允许尝试获取锁，避免线程阻塞。Condition接口用于线程间的协调，类似于wait()和notify()，提供了比wait()和notify()更灵活的线程协调机制，支持多个条件队列。Lock和Condition通常结合使用，以实现复杂的线程同步机制，如生产者-消费者问题。Lock的优势提供更灵活的锁控制（可重入、可中断、超时、公平锁）。
java中Condition类的详细介绍（详解）
08-04 6228
已找不到原文了，还望原文博主看到能告诉小白一下，一定标注原文地址 一 condition 介绍及demo 　Conditio...
Java中的Condition详解
向上的"狼"的博客
04-29 1万+
一、Condition简介 任意一个Java对象，都拥有一组监视器方法（定义在Object类中），主要包括wait，notify，notifyAll方法，这些方法与synchornized关键字相配合，可以实现等待/通知模式。 Condition接口也提供了类似的Object的监视器方法，与Lock配合可以实现等待/通知模式。但是这两者在使用方式以及功能上还是有差别的。 Condition定义了等待/通知两种类型的方法，当前线程调用这些方法时，需要提前获取到Condition对象关联的锁。Co
Java并发之Condition
a_higher的博客
11-16 265
Java并发之Condition 在使用Lock之前，我们使用的最多的同步方式应该是synchronized关键字来实现同步方式了。配合Object的wait()、notify()系列方法可以实现等待/通知模式。Condition接口也提供了类似Object的监视器方法，与Lock配合可以实现等待/通知模式，但是这两者在使用方式以及功能特性上还是有差别的。Object和Condition接口的一些对比。摘自《Java并发编程的艺术》 一、Condition接口介绍和示例 首先...
java condition使用及分析
热门推荐
bohu83的博客
04-08 2万+
背景：    上一篇文章基于object的wait、notify实现了生产者、消费者模式。本篇文章继续梳理Condition。condition 介绍及demo　Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition的await()、signal()...
Java并发编程：Condition详解与示例
"Java并发编程中的Condition条件控制详解" 在Java并发编程中，Condition是一个非常重要的概念，它提供了比传统的`synchronized`关键字更为精细的锁控制。Condition接口位于`java.util.concurrent.locks`包中，是...
Java 并发编程
weixin_46531416的博客
08-06 1087
Java 并发编程详解
Java并发编程线程间通讯实现过程详解
08-19
"Java并发编程线程间通讯实现过程详解" Java并发编程线程间通讯实现过程详解是Java编程中非常重要的一部分，涉及到多线程之间的数据共享、同步和通信。在Java中，线程间通讯可以通过多种方式实现，本文将通过示例...
Java并发编程：Condition条件阻塞详解及代码实例
"Java并发编程中的条件阻塞Condition在实际应用中的代码示例解析，包括Condition的基本使用和如何替代传统的wait/notify机制" 在Java并发编程中，Condition接口是Java.util.concurrent.locks包下的一个重要组成部分...
Java中的Condition
duhf_think的专栏
09-16 314
Condition调用await方法后，当前线程会释放锁并在此等待，而其他线程调用Condition对象的singal方法，通知当前线程，当前线程才从await方法返回，并且在返回前已经获取了锁。Condition的singalAll方法，相当于对等待队列的每个节点均执行一次singal方法，效果就是将等待队列中所有节点全部移动到同步队列，并唤醒每个节点的线程。调用await方法的线程成功获取了锁，该方法会将当前线程构造成节点并加入等待队列中，然后释放同步状态，唤醒同步队列中的后继节点。
Java 并发之 Condition 的实现分析
weixin_39793123的博客
10-10 221
一、Condition的概念   介绍   回忆 synchronized 关键字，它配合 Object 的 wait()、notify() 系列方法可以实现等待/通知模式。   对于 Lock，通过 Condition 也可以实现等待/通知模式。   Condition 是一个接口。 Condition 接口的实现类是 Lock（AQS）中的 ConditionObject...
Java多线程Condition接口原理详解
路漫漫，水迢迢
05-21 1万+
Condition接口提供了类似Object的监视器方法，与Lock配合可以实现等待/通知模式，但是这两者在使用方式以及功能特性上还是有差别的 Condition接口详解Condition定义了等待/通知两种类型的方法，当前线程调用这些方法时，需要提前获取到Condition对象关联的锁。Condition对象是由Lock对象（调用Lock对象的newCondition()方法）创建出来的，换句话
java中的condition
一棵小树
09-19 638
java中的condition Condition 将 Object 监视器方法（wait、notify 和 notifyAll）分解成截然不同的对象，以便通过将这些对象与任意 Lock 实现组合使用，为每个对象提供多个等待 set（wait-set）。其中，Lock 替代了 synchronized 方法和语句的使用，Condition 替代了 Object 监视器方法的使用。
JAVA Condition 详解
qq_37001674的博客
03-05 460
synchronized 关键字，配合Object的wait()、notify()系列方法可以实现等待/通知模式。对于Lock，通Condition也可以实现等待/通知模式。 Condition时一个接口，其实现类是AQS中的ConditionObject Lock对象通过newCondition()方法可以获得Condition对象（其实就是ConditionObject) Lock l...
JAVA 并发 - CONDITION
东哥_Jeffery的博客
03-28 309
java 并发 – condition 什么是condition？        Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition的await()、signal()这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition，阻塞队列实际上是使用了Condition
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值