java condition使用及分析

背景：

    上一篇文章基于object的wait、notify实现了生产者、消费者模式。本篇文章继续梳理Condition。

condition 介绍及demo

　Condition是在java 1.5中才出现的，它用来替代传统的Object的wait()、notify()实现线程间的协作，相比使用Object的wait()、notify()，使用Condition的await()、signal()这种方式实现线程间协作更加安全和高效。因此通常来说比较推荐使用Condition，阻塞队列实际上是使用了Condition来模拟线程间协作。

• Condition是个接口，基本的方法就是await()和signal()方法；
• Condition依赖于Lock接口，生成一个Condition的基本代码是lock.newCondition() 
•  调用Condition的await()和signal()方法，都必须在lock保护之内，就是说必须在lock.lock()和lock.unlock之间才可以使用

　　Conditon中的await()对应Object的wait()；

　　Condition中的signal()对应Object的notify()；

Condition中的signalAll()对应Object的notifyAll()。

下面是demo：　　

package thread;

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
/**
 *
 * @author zhangliang
 *
 * 2016年4月8日 下午5:48:54
 */
public class ConTest {

     final Lock lock = new ReentrantLock();
     final Condition condition = lock.newCondition();

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ConTest test = new ConTest();
        Producer producer = test.new Producer();
        Consumer consumer = test.new Consumer();


        consumer.start();
        producer.start();
    }

     class Consumer extends Thread{

            @Override
            public void run() {
                consume();
            }

            private void consume() {

                    try {
                           lock.lock();
                        System.out.println("我在等一个新信号"+this.currentThread().getName());
                        condition.await();

                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    } finally{
                        System.out.println("拿到一个信号"+this.currentThread().getName());
                        lock.unlock();
                    }

            }
        }

     class Producer extends Thread{

            @Override
            public void run() {
                produce();
            }

            private void produce() {
                    try {
                           lock.lock();
                           System.out.println("我拿到锁"+this.currentThread().getName());
                            condition.signalAll();
                        System.out.println("我发出了一个信号："+this.currentThread().getName());
                    } finally{
                        lock.unlock();
                    }
                }
     }

}

运行结果：

Condition的执行方式，是当在线程Consumer中调用await方法后，线程Consumer将释放锁，并且将自己沉睡，等待唤醒，线程Producer获取到锁后，开始做事，完毕后，调用Condition的signalall方法，唤醒线程Consumer，线程Consumer恢复执行。

以上说明Condition是一个多线程间协调通信的工具类，使得某个，或者某些线程一起等待某个条件（Condition）,只有当该条件具备( signal 或者 signalAll方法被带调用)时 ，这些等待线程才会被唤醒，从而重新争夺锁。

Condition实现生产者、消费者模式：

package thread;

import java.util.PriorityQueue;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConTest2 {
        private int queueSize = 10;
        private PriorityQueue queue = new PriorityQueue(queueSize);
        private Lock lock = new ReentrantLock();
        private Condition notFull = lock.newCondition();
        private Condition notEmpty = lock.newCondition();

        public static void main(String[] args) throws InterruptedException  {
            ConTest2 test = new ConTest2();
            Producer producer = test.new Producer();
            Consumer consumer = test.new Consumer();
            producer.start();
            consumer.start();
            Thread.sleep(0);
            producer.interrupt();
            consumer.interrupt();
        }

        class Consumer extends Thread{
            @Override
            public void run() {
                consume();
            }
            volatile boolean flag=true;
            private void consume() {
                while(flag){
                    lock.lock();
                    try {
                        while(queue.size() == 0){
                            try {
                                System.out.println("队列空，等待数据");
                                notEmpty.await();
                            } catch (InterruptedException e) {
                                flag =false;
                            }
                        }
                        queue.poll();                //每次移走队首元素
                        notFull.signal();
                        System.out.println("从队列取走一个元素，队列剩余"+queue.size()+"个元素");
                    } finally{
                        lock.unlock();
                    }
                }
            }
        }

        class Producer extends Thread{
            @Override
            public void run() {
                produce();
            }
            volatile boolean flag=true;
            private void produce() {
                while(flag){
                    lock.lock();
                    try {
                        while(queue.size() == queueSize){
                            try {
                                System.out.println("队列满，等待有空余空间");
                                notFull.await();
                            } catch (InterruptedException e) {

                                flag =false;
                            }
                        }
                        queue.offer(1);        //每次插入一个元素
                        notEmpty.signal();
                        System.out.println("向队列取中插入一个元素，队列剩余空间："+(queueSize-queue.size()));
                    } finally{
                        lock.unlock();
                    }
                }
            }
        }
    }

运行结果如下：

condition实现分析：

• Condition接口包含了多种await方式和两个通知方法
• ConditionObject实现了Condition接口，是AbstractQueuedSynchronizer的内部类
• Reentrantlock的newCondition方法返回与某个lock实例相关的Condition对象

public abstract class AbstractQueuedLongSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {

"font-size:18px;">结合上面的类图，我们看到condition实现是依赖于aqs，而aqs是个抽象类。里面定义了同步器的基本框架，实现了基本的结构功能。只留有状态条件的维护由具体同步器根据具体场景来定制，如常见的 ReentrantLock 、 RetrantReadWriteLock和CountDownLatch 等等，AQS内容太多，尽量只简明梳理condition相关流程，不太深入理解底层源码。

下面结合上面demo来分析流程。

reentrantLock.newCondition() 返回的是Condition的一个实现，该类在AbstractQueuedSynchronizer(AQS)中被实现，叫做newCondition（）

public Condition newCondition() {
    return sync.newCondition();
}

我们看一下这个await的方法，它是AQS的方法，

public final void await() throws InterruptedException {

02	if (Thread.interrupted())

03	throw new InterruptedException();

04	Node node = addConditionWaiter(); //将当前线程包装下后，

05	//添加到Condition自己维护的一个链表中。

06	int savedState = fullyRelease(node);//释放当前线程占有的锁，从demo中看到，

07	//调用await前，当前线程是占有锁的

08

09	int interruptMode = 0;

10	while (!isOnSyncQueue(node)) {//释放完毕后，遍历AQS的队列，看当前节点是否在队列中，

11	//不在 说明它还没有竞争锁的资格，所以继续将自己沉睡。

12	//直到它被加入到队列中，聪明的你可能猜到了，

13	//没有错，在singal的时候加入不就可以了？

14	LockSupport.park(this);

15	if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)

16

break;

17

}

18	//被唤醒后，重新开始正式竞争锁，同样，如果竞争不到还是会将自己沉睡，等待唤醒重新开始竞争。

19	if (acquireQueued(node, savedState) && interruptMode != THROW_IE)

20	interruptMode = REINTERRUPT;

21	if (node.nextWaiter != null)

22	unlinkCancelledWaiters();

23	if (interruptMode != 0)

24	reportInterruptAfterWait(interruptMode);

25

}

回到上面的demo，锁被释放后，线程Consumer开始沉睡，这个时候线程因为线程Consumer沉睡时，会唤醒AQS队列中的头结点，所所以线程Producer会开始竞争锁，并获取到，执行完后线程Producer会调用signal方法，“发出”signal信号，signal方法如下：

1	public final void signal() {

2	if (!isHeldExclusively())

3	throw new IllegalMonitorStateException();

4	Node first = firstWaiter; //firstWaiter为condition自己维护的一个链表的头结点，

5	//取出第一个节点后开始唤醒操作

6	if (first != null)

7	doSignal(first);

8

}

说明下，其实Condition内部维护了等待队列的头结点和尾节点，该队列的作用是存放等待signal信号的线程，该线程被封装为Node节点后存放于此。

而Condition自己也维护了一个队列，该队列的作用是维护一个等待signal信号的队列，两个队列的作用是不同，事实上，每个线程也仅仅会同时存在以上两个队列中的一个，流程是这样的：

注意：

1.线程producer调用signal方法，这个时候Condition的等待队列中只有线程Consumer一个节点，于是它被取出来，并被加入到AQS的等待队列中。  注意，这个时候，线程Consumer 并没有被唤醒。

2.Sync是AQS的抽象子类，实现可重入和互斥的大部分功能。在Sync的子类中有FairSync和NonfairSync两种代表公平锁策略和非公平锁策略。Sync lock方法留给子类去实现，NonfairSync的实现：

final void lock() {
           if (compareAndSetState(0, 1))
               setExclusiveOwnerThread(Thread.currentThread());
           else
               acquire(1);
       }

其中如果一开始获取锁成功，是直接设置当前线程。

否则执行acquire(1),也就是进入aqs等待队列。这里不展开细节。

可以这样理解，整个协作过程是靠结点在AQS的等待队列和Condition的等待队列中来回移动实现的，每个队列的意义不同，Condition作为一个条件类，很好的自己维护了一个等待信号的队列，并在适时的时候将结点加入到AQS的等待队列中来实现的唤醒操作

本文先整理到这里吧。

后记：

梳理本文的过程比较痛苦，为什么呢？因为我没有吃透这一块，发现牵扯的很多，脑子很乱，有广度又有深度，感觉没法梳理，决定一点一点去啃，从浅入深的去梳理，从锁，同步，阻塞队列，并发容器开始，到依赖的底层aqs\原子变量，再到更底层的volatile、cas。其中aqs是其中的关键，很多j.u.c的包是围绕它实现的。目标就是会用，熟悉原理，读懂源码，写出demo，关键地方梳理出流程图，加油！

参考：

http://www.cnblogs.com/dolphin0520/p/3920385.html

http://ifeve.com/understand-condition/

http://ifeve.com/java-special-troops-aqs/

最近在看pthread方面的书，看到条件变量一节的时候，回忆了下java中条件变量的使用方式。

java中条件变量都实现了java.util.concurrent.locks.Condition接口，条件变量的实例化是通过一个Lock对象上调用newCondition()方法来获取的，这样，条件就和一个锁对象绑定起来了。因此，Java中的条件变量只能和锁配合使用，来控制并发程序访问竞争资源的安全。

 

条件变量的出现是为了更精细控制线程等待与唤醒，在Java5之前，线程的等待与唤醒依靠的是Object对象的wait()和notify()/notifyAll()方法，这样的处理不够精细。

通熟易懂的说，就是消费者/生产者的场景中，在原来的基础上，增加了队列满时及时通知消费者，队列空时及时通知生产者的优化，通常是两个条件变量一起出现，一个控制值，但两个条件变量可以毫无关系，终归来说还是在Lock的范围内。所以，从本质上来说，是对Object监视器的场景性优化，而不是全新机制的引入。

 

从现实应用角度来说，它们常被用于下列场景：

1、写log。比如每1秒或者commit或者日志大于1/3m时候都写入。缓存中大于1/3m时需要等写入完成才能commit。

 

而在Java5中，一个锁可以有多个条件，每个条件上可以有多个线程等待，通过调用await()方法，可以让线程在该条件下等待。当调用signalAll()方法，又可以唤醒该条件下的等待的线程。有关Condition接口详细说明可以具体参考JavaAPI文档。

如下：public class TestConditon

按 Ctrl+C 复制代码

按 Ctrl+C 复制代码

需要注意的是，在共用一个线程池的设计中，特别要注意饿死现象（就像上下高速如果公用车道的话，万一进入的10车全部占坑了，高速里面又满了的话，想出的都出不来，进的进不去，就出现饿死现象了），如果有大量的消费者使得生产者线程无法再运行的话，就会出现该问题，在上述例子中，将线程池数量从3改成2就可以多次测试中发现程序hang了。

所以，我们可以看到典型的在RDBMS系统中都是各种线程各司其职。