java并发包之Condition

一、前言

之前在AQS中介绍到其中的Condition队列，而今天本文就介绍与其相关的Condition。Condition是一个多线程间协调通信的工具类，在synchornize中，使用的是wait和notify来实现，而Condition除了实现wait和notify的功能以外，他的好处在于一个lock可以创建多个Condition，可以选择性的通知wait的线程，接下来看下具体的介绍。

二、主要特点

  1. Condition 的前提是Lock，由AQS中newCondition()方法 创建Condition的对象
  2. Condition await方法表示线程从AQS中移除，并释放线程获取的锁，并进入Condition等待队列中等待，等待被signal
  3. Condition signal方法表示唤醒对应Condition等待队列中的线程节点，并加入AQS中，准备去获取锁。

三、流程示意图：

  1. 有三个节点在AQS中，三个线程分别触发了lock的lock方法，三个节点还处于锁的竞争状态，都在AQS队列中，而已经有两个节点在Condition队列中。

  2. 节点1执行Condition.await()，先在Condition队列队尾添加节点，并释放节点1的锁，并把节点1加入到等待队列中，并把lastWaiter更新为节点1

  3. 节点2执行signal()，将节点4移出Codition队列，并将节点4加入AQS队列中等待获取锁资源

四、源码分析

4.1 await()

  public final void await() throws InterruptedException {
            
            if (Thread.interrupted()) throw new InterruptedException();
            //将当前线程包装成NODE，并将其添加到Condition队列中
            Node node = addConditionWaiter();
            //释放当前线程占有的锁资源
            int savedState = fullyRelease(node);
            int interruptMode = 0;
            //遍历AQS队列，判断节点是否在AQS队列中
            //如果不在说明没有获取锁的资格，则继续阻塞，直到被加入到队列中
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
           //如果被唤醒，则重新开始获取资源，
           //如果竞争不到则继续休眠，等待被唤醒
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT; 
            //检测线程是中断唤醒还是锁释放唤醒，因为如果中断唤醒的节点仍然存在Condition队列中，所以需要从Condition中删除
            if (node.nextWaiter != null) 
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }

4.1.1 addConditionWaiter()

加入Condition队列方法，并没有像AQS队列中那样处理并发情况，是因为在操作Condition的时候当前线程已经获取了AQS独占的资源，所以不用考虑并发问题

   private Node addConditionWaiter() {
            Node t = lastWaiter;
            //1. 如果尾节点已经Cancel，直接清除。出现该情况
            //是线程被中断时或超时，await()方法中checkInterruptWhileWaiting方法调用
            //transferAfterCancelledWait导致
            if (t != null && t.waitStatus != Node.CONDITION) {
                //对t.waitStatus != Node.CONDITION的节点进行删除
                unlinkCancelledWaiters();
                t = lastWaiter;
            }
            //把当前节点封装成NODE放入Condition队列
            Node node = new Node(Thread.currentThread(), Node.CONDITION);
            if (t == null)
                firstWaiter = node;
            else
                t.nextWaiter = node;
            lastWaiter = node;
            return node;
        }

4.1.2 unlinkCancelledWaiters()

清除Condition队列中因超时或者中断而还存在的点（这些节点不是Condition应该被删除）

    private void unlinkCancelledWaiters() {
            Node t = firstWaiter;
            Node trail = null;
            while (t != null) {
                Node next = t.nextWaiter;
                if (t.waitStatus != Node.CONDITION) {
                    //如果节点不为Condition状态，则将对应节点的next删除
                    t.nextWaiter = null；
                    if (trail == null)
                        //next节点赋予fistWaiter相当于删除t节点
                        firstWaiter = next;
                    else
                        //同样也是删除t节点操作
                        trail.nextWaiter = next;
                    if (next == null)
                        lastWaiter = trail;
                }
                else
                    trail = t;
                //从下一个节点开始处理
                t = next;
            }
        }

4.1.3 isOnSyncQueue(Node)

final boolean isOnSyncQueue(Node node) {
        //如果节点状态是Condition或者node.prev为空则返回false，因为如果节点状态是Condition，说明该节点只会存在于Condition队列中，而之前说过AQS是个双向链表而Condition是个单向链表，而在入AQS队列之前会分配其前驱节点。
        if (node.waitStatus == Node.CONDITION || node.prev == null)
            return false;
        //同理因为在AQS队列中会分配node的next节点
        if (node.next != null)
            return true;
        //如果前面判断完了，则从同步队列中遍历判断是否有当前节点
        return findNodeFromTail(node);

4.2 signal()

将Condition队列中等待的线程节点，转移到AQS队列中

   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;
                first.nextWaiter = null;
            //将first节点移动到AQS队列中
            } while (!transferForSignal(first) &&
                     (first = firstWaiter) != null);
        }

    final boolean transferForSignal(Node node) {
        //CAS控制将节点状态转化为0
        if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
            return false;
        //调用之前AQS的enq方法将节点加入到AQS中
        Node p = enq(node);
        int ws = p.waitStatus;
        //并将节点状态处理成SIGNAL
        if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
            LockSupport.unpark(node.thread);
        return true;
    }

正常情况下ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL)是不会触发的，所以线程一般不会在这里唤醒，只有在signal以后继续调用lock.unlock，由于节点在AQS队列中，如果获取锁资源则会被唤醒。

五、使用场景

5.1 顺序打印ABC问题

实现代码：

public class printer {

    private volatile char currentTheadName = 'a';
    private ReentrantLock lock = new ReentrantLock();

    Condition aCondition = lock.newCondition();
    Condition bCondition = lock.newCondition();
    Condition cCondition = lock.newCondition();



    public class printAThread implements Runnable{

        public void run() {
            for (int i = 0; i < 10; i++) {
                lock.lock();
                try {
                    while (currentTheadName != 'a'){
                        aCondition.await();
                    }
                    System.out.println("第"+i+"次打印"+"Print A");
                    currentTheadName = 'b';
                    bCondition.signal();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    public class printBThread implements Runnable{

        public void run() {
            for (int i = 0; i < 10; i++) {
                lock.lock();
                try {
                    while (currentTheadName != 'b'){
                        bCondition.await();
                    }
                    System.out.println("第"+i+"次打印"+"Print B");
                    currentTheadName = 'c';
                    cCondition.signal();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }



    public class printCThread implements Runnable{

        public void run() {
            for (int i = 0; i < 10; i++) {
                lock.lock();
                try {
                    while (currentTheadName != 'c'){
                        cCondition.await();
                    }
                    System.out.println("第"+i+"次打印"+"Print C");
                    currentTheadName = 'a';
                    aCondition.signal();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }

    public static void main(String[] args) {
        printer printer = new printer();
        ExecutorService service = Executors.newFixedThreadPool(3);
        service.execute(printer.new printAThread());
        service.execute(printer.new printBThread());
        service.execute(printer.new printCThread());

        service.shutdown();
    }

}

返回结果：

第1次打印Print A
第1次打印Print B
第1次打印Print C
第2次打印Print A
第2次打印Print B
第2次打印Print C
第3次打印Print A
第3次打印Print B
第3次打印Print C
第4次打印Print A
第4次打印Print B
第4次打印Print C
第5次打印Print A
第5次打印Print B
第5次打印Print C
第6次打印Print A
第6次打印Print B
第6次打印Print C
第7次打印Print A
第7次打印Print B
第7次打印Print C
第8次打印Print A
第8次打印Print B
第8次打印Print C
第9次打印Print A
第9次打印Print B
第9次打印Print C

5.2 生产者和消费者问题

public class ProducerAndConsumer {

    private static List<Object> bufferList = new ArrayList();

    private static final int MAX_SIZE = 10;

    private static ReentrantLock lock = new ReentrantLock();

    private static Condition empty = lock.newCondition();
    private static Condition full = lock.newCondition();

    public class Producer implements Runnable{

        public void run() {
            lock.lock();
            try {
                while (bufferList.size() >= MAX_SIZE){
                    System.out.println("buff is full");
                    empty.await();
                }
                bufferList.add(new Object());
                System.out.println("producer produce one , buffe size is " + bufferList.size());
                full.signalAll();
            } catch (InterruptedException e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }
    }

    public class Consumer implements Runnable{

        public void run() {
            lock.lock();
            try {
                while (bufferList.size() <= 0){
                    System.out.println("buff is empty");
                    full.await();
                }
                bufferList.remove(0);
                System.out.println("consume the head one , buffe size is " + bufferList.size());
                empty.signalAll();
            }catch (InterruptedException e){
                e.printStackTrace();
            }finally {
                lock.unlock();
            }
        }

    }

    public static void main(String[] args) {
        ProducerAndConsumer producerAndConsumer = new ProducerAndConsumer();
        int producerCount = 10;

        int consumer = 6;

        for (int j = 0 ; j <= consumer ; j++){
            new Thread(producerAndConsumer.new Consumer()).start();
        }
        
        for (int i = 0 ; i <= producerCount ; i++){
            new Thread(producerAndConsumer.new Producer()).start();
        }
    }
}

返回结果：

buff is empty
buff is empty
buff is empty
buff is empty
buff is empty
buff is empty
buff is empty
producer produce one , buffe size is 1
consume the head one , buffe size is 0
buff is empty
buff is empty
buff is empty
buff is empty
buff is empty
buff is empty
producer produce one , buffe size is 1
consume the head one , buffe size is 0
buff is empty
buff is empty
buff is empty
buff is empty
buff is empty
producer produce one , buffe size is 1
producer produce one , buffe size is 2
consume the head one , buffe size is 1
consume the head one , buffe size is 0
buff is empty
buff is empty
buff is empty
producer produce one , buffe size is 1
consume the head one , buffe size is 0
buff is empty
buff is empty
producer produce one , buffe size is 1
consume the head one , buffe size is 0
buff is empty
producer produce one , buffe size is 1
consume the head one , buffe size is 0
producer produce one , buffe size is 1
producer produce one , buffe size is 2
producer produce one , buffe size is 3
producer produce one , buffe size is 4
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,454评论 6赞 493
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,553评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,921评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,648评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,770评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,950评论 1赞 291
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,090评论 3赞 410
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,817评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,275评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,592评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,724评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,409评论 4赞 333
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 40,052评论 3赞 316
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,815评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,043评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,503评论 2赞 361
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,627评论 2赞 350

推荐阅读更多精彩内容