越努力,越幸运

微信公众号:JoonWhee。专注于Java原创知识交流,优秀技术文章、职场人生、面试经验分享。...

Java并发:Condition详解

概述

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

通过对比Object的监视器方法和Condition接口,可以更详细地了解Condition的特性,对比项与结果如下表。



Condition的使用

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

package com.joonwhee.five;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * Condition接口与示例
 * 
 * @author JoonWhee
 * @Date 2018年2月11日
 * @param <T>
 */
public class BoundedQueue<T> {

    // 线程池
    private static ExecutorService THREAD_POOL = new ThreadPoolExecutor(2, 4, 60, TimeUnit.MINUTES,
            new LinkedBlockingQueue<Runnable>(1000), Executors.defaultThreadFactory(),
            new ThreadPoolExecutor.AbortPolicy());

    private Object[] items; // 对象数组
    // 添加的下标,删除的下标和数组当前数量
    private int addIndex, removeIndex, count;
    private Lock lock = new ReentrantLock(); // 定义一个可重入锁
    private Condition notEmpty = lock.newCondition(); // 添加一个Condition
    private Condition notFull = lock.newCondition(); // 添加一个Condition

    public BoundedQueue(int size) {
        items = new Object[size];
    }

    /**
     * 添加一个元素,如果数组满,则添加线程进入等待状态,直到有"空位"
     * @param t
     * @throws InterruptedException
     */
    public void add(T t) throws InterruptedException {
        lock.lock(); // 获取锁
        try {
            while (count == items.length) { // 如果数组满了,notFull进入等待
                System.out.println("items满了,add方法进入等待.");
                notFull.await(); // 等待remove方法里的notFull.signal()
            }

            items[addIndex] = t; // item添加对象
            if (++addIndex == items.length) // 调整数组索引,避免越界
                addIndex = 0;
            ++count; // count+1,代表添加了一个对象
            notEmpty.signal(); // 走到这里,数组里至少有1个对象,必不为空,因此唤醒notEmpty
        } finally {
            System.out.println("add: " + t);
            lock.unlock(); // 释放锁
        }
    }

    /**
     * 由头部删除一个元素,如果数组空,则删除线程进入等待状态,
     * 直到有新添加元素(注意这里并没有真的删除元素,只是把count-1当作是删除)
     * @return
     * @throws InterruptedException
     */
    @SuppressWarnings("unchecked")
    public T remove() throws InterruptedException {
        lock.lock(); // 获取锁
        try {
            while (count == 0) { // 如果数组为空,notEmpty进入等待
                System.out.println("items为空,remove方法进入等待.");
                notEmpty.await(); // 等待add方法里的notEmpty.signal()
            }

            Object x = items[removeIndex]; // item移除对象(假移除)
            if (++removeIndex == items.length) // 调整数组索引,避免越界
                removeIndex = 0;
            --count; // count-1,代表移除了一个对象
            notFull.signal(); // 走到这里,数组里至少有1个空位,必不为满,因此唤醒notFull
            return (T) x;
        } finally {
            System.out.println("remove");
            lock.unlock(); // 释放锁
        }
    }

    public static void main(String args[]) throws InterruptedException {
        int count = 3; // 可以加大数组的size来看更多的过程
        BoundedQueue<Integer> bq = new BoundedQueue<Integer>(count);

        // 开启一个线程执行添加操作
        THREAD_POOL.submit(new Callable<Object>() {
            public Object call() throws InterruptedException {
                for (int i = 0; i < count * 2; i++) {
                    bq.add(i);
                    Thread.sleep(200); // 通过睡眠来制造添加和移除的速度差
                }
                return null;
            }
        });

        // 开启一个线程执行移除操作
        THREAD_POOL.submit(new Callable<Object>() {
            public Object call() throws InterruptedException {
                Thread.sleep(1000);
                for (int i = 0; i < count * 2; i++) {
                    bq.remove();
                    Thread.sleep(50); // 通过睡眠来制造添加和移除的速度差
                }
                return null;
            }
        });
    }
}
输出如下,由于调用remove方法的线程先睡眠了1秒,所以,add方法会先将item数组填满,填满后notFull进入等待。之后,remove方法的线程醒来开始进行移除,当移除之后会唤醒notFull,此时add和remove是并发操作的,但是由于remove的速度更快(通过sleep控制,add每次要睡200毫秒,remove只要50毫秒),所以items必然会被移除到为空,此时notEmpty进入等待,直到add方法往item添加了对象,如此反复。



重要入口方法

Condition的实现主要包括:条件队列、等待和通知。其中条件队列放的是AQS里的Node数据结构,使用nextWaiter来维护条件队列。等待和通知共有7个方法。

  • signal():唤醒该条件队列的头节点。
  • signalAll():唤醒该条件队列的所有节点。
  • awaitUninterruptibly():等待,此方法无法被中断,必须通过唤醒才能解除阻塞。
  • await():当前线程进入等待。
  • awaitNanos(long):当前线程进入等待,有超时时间,入参的单位为纳秒。
  • awaitUntil(Date):当先线程进入等待,直到当前时间超过入参的时间。
  • await(long, TimeUnit):当前线程进入等待,有超时时间,入参可以自己设置时间单位。
这些方法其实大同小异,因此本文只对常用的signal()、signalAll()和await()方法展开详解。搞懂了这3个方法,搞懂其他几个方法也基本没什么阻碍。

基础属性

Condition的实现是ConditionObject,而ConditionObject是同步器AbstractQueuedSynchronizer的内部类,因为Condition的操作需要获取相关联的锁,所以作为同步器的内部类也较为合理。每个Condition对象都包含着一个队列(以下称为条件队列),该队列是Condition对象实现等待/通知功能的关键。

private static final long serialVersionUID = 1173984872572414699L;
/** First node of condition queue. */
private transient Node firstWaiter; // 条件队列的头节点
/** Last node of condition queue. */    
private transient Node lastWaiter;  // 条件队列的尾节点

/**
 * Creates a new {@code ConditionObject} instance.
 */
public ConditionObject() { }
通过源码可知,条件队列的节点使用的是AQS的Node数据结构。(Node的数据结构见:Node的数据结构

另外,由于ConditionObject是AQS的内部类,因此必然和AQS是有很多关联的,因此看本文之前必须先了解AQS的实现原理。(如果你对AQS不熟悉,可以参考我的另一篇文章:Java并发:AbstractQueuedSynchronizer详解(独占模式)

条件队列的基本数据结构如下图中的“条件队列”:


await方法

public final void await() throws InterruptedException { // 阻塞当前线程,直接被唤醒或被中断
    if (Thread.interrupted())   // 如果当前线程被中断过,则抛出中断异常
        throw new InterruptedException();
    Node node = addConditionWaiter();   // 添加一个waitStatus为CONDITION的节点到条件队列尾部
    int savedState = fullyRelease(node);    // 释放操作。我们知道只有在拥有锁(acquire成功)的时候才能调用await()方法,因此,调用await()方法的线程的节点必然是同步队列的头节点。所以,当调用await()方法时,相当于同步队列的首节点(获取了锁的节点)移动到Condition的条件队列中。
    int interruptMode = 0;  // 0为正常,被中断值为THROW_IE或REINTERRUPT
    while (!isOnSyncQueue(node)) {  // isOnSyncQueue:判断node是否在同步队列(注意和条件队列区分。调用signal方法会将节点从条件队列移动到同步队列,因此这边就可以跳出while循环)
        LockSupport.park(this); // node如果不在同步队列则进行park(阻塞当前线程)
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)    // 检查线程被唤醒是否是因为被中断,如果是则跳出循环,否则会进行下一次循环,因为被唤醒前提是进入同步队列,所以下一次循环也必然会跳出循环
            break;
    }
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)   // acquireQueued返回true代表被中断过,如果中断模式不是THROW_IE,则必然为REINTERRUPT(见上面的checkInterruptWhileWaiting方法)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null) // clean up if cancelled
        unlinkCancelledWaiters();   // 移除waitStatus为CANCELLED的节点
    if (interruptMode != 0) // 如果跳出while循环是因为被中断
        reportInterruptAfterWait(interruptMode);    // 则根据interruptMode,选择抛出InterruptedException 或 重新中断当前线程
}
  1. 如果当前线程被中断过,则抛出中断异常。
  2. 调用addConditionWaiter方法(详解见下文addConditionWaiter方法)添加一个waitStatus为CONDITION的节点到条件队列尾部。
  3. 调用fullyRelease方法(详解见下文fullyRelease方法)释放锁。
  4. 调用isOnSyncQueue方法(详解见下文isOnSyncQueue方法)来阻塞线程,直到被唤醒或被中断。
  5. 调用acquireQueued方法(详解见acquireQueued方法详解)来尝试获取锁,并判断线程跳出while循环是被唤醒还是被中断。
  6. 如果跳出while循环是因为被中断,则根据interruptMode,选择抛出InterruptedException 或 重新中断当前线程。

addConditionWaiter方法

private Node addConditionWaiter() { // 添加一个waitStatus为CONDITION的节点到条件队列尾部
    Node t = lastWaiter;
    // If lastWaiter is cancelled, clean out.
    if (t != null && t.waitStatus != Node.CONDITION) {
        unlinkCancelledWaiters();   // 移除waitStatus不为CONDITION的节点(条件队列里的节点waitStatus都为CONDITION)
        t = lastWaiter; // 将t赋值为移除了waitStatus不为CONDITION后的尾节点(上面进行了移除操作,因此尾节点可能会发生变化)
    }
    Node node = new Node(Thread.currentThread(), Node.CONDITION);   // 以当前线程新建一个waitStatus为CONDITION的节点
    if (t == null)  // t为空,代表条件队列为空
        firstWaiter = node; // 将头节点赋值为node
    else
        t.nextWaiter = node;    // 否则,队列不为空。将t(原尾节点)的后继节点赋值为node
    lastWaiter = node;  // 将node赋值给尾节点,即将node放到条件队列的尾部。这里没有用CAS来保证原子性,原因在于调用await()方法的线程必定是获取了锁的线程,也就是说该过程是由锁来保证线程安全的
    return node;
}
  1. 如果条件队列的尾节点不为null并且waitStatus不为CONDITION,则调用unlinkCancelledWaiters方法(详解见下文unlinkCancelledWaiters方法)移除waitStatus不为CONDITION的节点(条件队列里的节点waitStatus都为CONDITION),并将t赋值为移除了waitStatus不为CONDITION后的尾节点(上面进行了移除操作,因此尾节点可能会发生变化)
  2. 以当前线程新建一个waitStatus为CONDITION的节点。
  3. 如果t为空,代表条件队列为空,将头节点赋值为node;否则,队列不为空。将t(原尾节点)的后继节点赋值为node。
  4. 最后将node赋值给尾节点,即将node放到条件队列的尾部。这里没有用CAS来保证原子性,原因在于调用await()方法的线程必定是获取了锁的线程,也就是说该过程是由锁来保证线程安全的。

unlinkCancelledWaiters方法

private void unlinkCancelledWaiters() { // 从条件队列移除所有waitStatus不为CONDITION的节点
    Node t = firstWaiter; // t赋值为条件队列的尾节点  
    Node trail = null;
    while (t != null) {
        Node next = t.nextWaiter;   // 向下遍历
        if (t.waitStatus != Node.CONDITION) {   // 如果t的waitStatus不为CONDITION
            t.nextWaiter = null;    // 断开t与t后继节点的关联
            if (trail == null)  // 如果trail为null,则将firstWaiter赋值为next节点,此时还没有遍历到waitStatus为CONDITION的节点,因此直接移动firstWaiter的指针即可移除前面的节点
                firstWaiter = next; 
            else
                trail.nextWaiter = next;    // 否则将trail的后继节点设为next节点。此时,trail节点到next节点中的所有节点被移除(包括t节点,但可能不止t节点。因为,trail始终指向遍历过的最后一个waitStatus为CONDITION,因此只需要将trail的后继节点设置为next,即可将trail之后到next之前的所有节点移除)
            if (next == null)
                lastWaiter = trail;
        }
        else
            trail = t;  // 如果t的waitStatus为CONDITION,则将trail赋值为t,trail始终指向遍历过的最后一个waitStatus为CONDITION
        t = next;   // t指向下一个节点
    }
}
  1. 将t赋值为条件队列的尾节点 。
  2. 从t开始遍历整个条件队列。
  3. 如果t的waitStatus不为CONDITION,则断开t与t后继节点的关联。
  4. 如果trail为null,则将firstWaiter赋值为next节点,此时还没有遍历到waitStatus为CONDITION的节点,因此直接移动firstWaiter的指针即可移除前面的节点。
  5. 如果trail不为null,则将trail的后继节点设为next节点。此时,trail节点到next节点中的所有节点被移除(包括t节点,但可能不止t节点。因为,trail始终指向遍历过的最后一个waitStatus为CONDITION,因此只需要将trail的后继节点设置为next,即可将trail之后到next之前的所有节点移除)
  6. 如果t的waitStatus为CONDITION,则将trail赋值为t,trail始终指向遍历过的最后一个waitStatus为CONDITION。
  7. 最后将 t指向下一个节点,准备开始下一次循环。
例子图解过程:



fullyRelease方法

final int fullyRelease(Node node) { // 释放锁
    boolean failed = true;
    try {
        int savedState = getState();    // 当前的同步状态
        if (release(savedState)) {  // 独占模式下release(一般指释放锁)
            failed = false;
            return savedState;
        } else {
            throw new IllegalMonitorStateException();
        }
    } finally {
        if (failed)
            node.waitStatus = Node.CANCELLED;   // 如果release失败则将该节点的waitStatus设置为CANCELLED
    }
}
调用release方法(详解见release方法详解)释放锁,如果释放失败,则将该节点的waitStatus设置为CANCELLED。

isOnSyncQueue方法

final boolean isOnSyncQueue(Node node) {    // 判断node是否再同步队列中
    if (node.waitStatus == Node.CONDITION || node.prev == null) // 如果waitStatus为CONDITION 或 node没有前驱节点,则必然不在同步队列,直接返回false
        return false;
    if (node.next != null) // If has successor, it must be on queue 如果有后继节点,必然是在同步队列中,返回true
        return true;
    /*
     * node.prev can be non-null, but not yet on queue because
     * the CAS to place it on queue can fail. So we have to
     * traverse from tail to make sure it actually made it.  It
     * will always be near the tail in calls to this method, and
     * unless the CAS failed (which is unlikely), it will be
     * there, so we hardly ever traverse much.
     */
    return findNodeFromTail(node);  // 返回node是否为同步队列节点,如果是返回true,否则返回false
}
返回node是否为同步队列节点,如果是返回true,否则返回false。因为只有该节点的线程被唤醒(signal())才会从条件队列移到同步队列。

findNodeFromTail方法

private boolean findNodeFromTail(Node node) {   // 从同步队列的尾节点开始向前遍历,如果node为同步队列节点则返回true,否则返回false
    Node t = tail;
    for (;;) {
        if (t == node)
            return true;
        if (t == null)
            return false;
        t = t.prev;
    }
}
从同步队列的尾节点开始向前遍历,如果node为同步队列节点则返回true,否则返回false。

signal方法

public final void signal() {
    if (!isHeldExclusively())   // 检查当前线程是否为独占模式同步器的所有者
        throw new IllegalMonitorStateException();
    Node first = firstWaiter;   
    if (first != null)
        doSignal(first);    // 唤醒条件队列的头节点
}
  1. 检查当前线程是否为独占模式同步器的所有者,在ReentrantLock中即检查当前线程是否为拥有锁的线程。如果不是,则抛IllegalMonitorStateException。
  2. 拿到条件队列的头节点,如果不为null,则调用doSignal方法(详解见下文doSignal方法)唤醒头节点。

doSignal方法

private void doSignal(Node first) { // 将条件队列的头节点移到同步队列
    do {
        if ( (firstWaiter = first.nextWaiter) == null)  // 将first节点赋值为first节点的后继节点(相当于移除first节点),如果first节点的后继节点为空,则将lastWaiter赋值为null
            lastWaiter = null; 
        first.nextWaiter = null;    // 断开first节点对first节点后继节点的关联
    } while (!transferForSignal(first) &&   // transferForSignal:将first节点从条件队列移动到同步队列
             (first = firstWaiter) != null);    // 如果transferForSignal失败,并且first节点不为null,则向下遍历条件队列的节点,直到节点成功移动到同步队列 或者 firstWaiter为null
}
  1. 将first节点赋值为first节点的后继节点(相当于移除first节点),如果first节点的后继节点为空,则将lastWaiter赋值为null。
  2. 断开first节点与first节点后继节点的关联。
  3. 调用transferForSignal方法(详解见下文transferForSignal方法)将first节点从条件队列移动到同步队列。
  4. 如果transferForSignal失败,并且first节点的后继节点(firstWaiter)不为null,则向下遍历条件队列的节点,直到节点成功移动到同步队列 或者 first节点的后继节点为null。

transferForSignal方法

final boolean transferForSignal(Node node) {    // 将node节点从条件队列移动到同步队列,如果成功则返回true。
    /*
     * If cannot change waitStatus, the node has been cancelled.
     */
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))  // 如果不能更改节点的waitStatus,则表示该节点已被取消,返回false
        return false;

    /*
     * Splice onto queue and try to set waitStatus of predecessor to
     * indicate that thread is (probably) waiting. If cancelled or
     * attempt to set waitStatus fails, wake up to resync (in which
     * case the waitStatus can be transiently and harmlessly wrong).
     */
    Node p = enq(node); // 否则,调用enq方法将node添加到同步队列,注意:enq方法返回的节点是node的前驱节点
    int ws = p.waitStatus;  // 将ws赋值为node前驱节点的等待状态
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL)) // 如果node前驱节点的状态为CANCELLED(ws>0) 或 使用CAS将waitStatus修改成SIGNAL失败,则代表node的前驱节点无法来唤醒node节点,因此直接调用LockSupport.unpark方法唤醒node节点
        LockSupport.unpark(node.thread);
    return true;
}
  1. 如果不能更改节点的waitStatus,则表示该节点已被取消,返回false。
  2. 调用enq方法(详解见enq方法详解)将node添加到同步队列,注意:enq方法返回的节点是node的前驱节点。因此,此时p节点为node的前驱节点。
  3. 将ws赋值为node前驱节点(p节点)的waitStatus。
  4. 如果p节点的waitStatus为CANCELLED(ws>0) 或 使用CAS将p节点的waitStatus修改成SIGNAL失败,则代表p节点无法来唤醒node节点,因此直接调用LockSupport.unpark方法唤醒node节点。

signalAll方法

public final void signalAll() {
    if (!isHeldExclusively())   // 检查当前线程是否为独占模式同步器的所有者
        throw new IllegalMonitorStateException();
    Node first = firstWaiter;
    if (first != null)
        doSignalAll(first); // 唤醒条件队列的所有节点
}
  1. 检查当前线程是否为独占模式同步器的所有者,在ReentrantLock中即检查当前线程是否为拥有锁的线程。如果不是,则抛IllegalMonitorStateException。
  2. 拿到条件队列的头节点,如果不为null,则调用doSignalAll方法(详解见下文doSignalAll方法)唤醒条件队列的所有节点。

doSignalAll方法

private void doSignalAll(Node first) {  // 将条件队列的所有节点移到同步队列
    lastWaiter = firstWaiter = null;    // 因为要移除条件队列的所有节点到同步队列,因此这边直接将firstWaiter和lastWaiter赋值为null
    do {
        Node next = first.nextWaiter;   // next赋值为first节点的后继节点      
        first.nextWaiter = null;    // 断开first节点对first节点后继节点的关联
        transferForSignal(first);   // transferForSignal:将first节点从条件队列移动到同步队列
        first = next;   // first赋值为next节点
    } while (first != null);    // 循环遍历,将条件队列的所有节点移动到同步队列
}
  1. 因为要移除条件队列的所有节点到同步队列,因此这边直接将firstWaiter和lastWaiter赋值为null。
  2. next赋值为first节点的后继节点 。
  3. 断开first节点对first节点后继节点的关联
  4. 调用transferForSignal方法(详解见上文transferForSignal方法)将first节点从条件队列移动到同步队列。
  5. first赋值为next节点,准备下一次循环。
  6. 如果first不为null,则进入下一次循环。

总结

  1. 调用await和signal方法都需要先获得锁,否则会抛异常。
  2. 调用await方法会新建一个waitStatus为CONDITION、线程为当前线程的节点到条件队列尾部,然后当前线程会释放掉锁,并进入阻塞状态,直到该节点被移到同步队列或者被中断。该节点被移动到同步队列,并不代表该节点线程能立马获得锁,还是需要在同步队列中排队并在必要时候(前驱节点为head)调用tryAcquire方法去获取,如果获取成功则代表获得了锁。
  3. 调用signal方法会将条件队列的头节点移动到同步队列。

参考

AbstractQueuedSynchronizer.ConditionObject源码(JDK 1.8)
《Java并发编程的艺术》


—————END—————


阅读更多
版权声明:本文为博主原创文章,未经博主允许不得转载。微信公众号:JoonWhee,欢迎关注。 https://blog.csdn.net/v123411739/article/details/79321408
个人分类: Java并发
想对作者说点什么? 我来说一句

没有更多推荐了,返回首页

不良信息举报

Java并发:Condition详解

最多只允许输入30个字

加入CSDN,享受更精准的内容推荐,与500万程序员共同成长!
关闭
关闭