转自：https://blog.csdn.net/bohu83/article/details/51098106
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<Integer> queue = new PriorityQueue<Integer>(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.isEmpty()){
- 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 {
- <span style="font-size:18px;">结合上面的类图，我们看到condition实现是依赖于aqs，而aqs是个抽象类。里面定义了同步器的基本框架，实现了基本的结构功能。只留有状态条件的维护由具体同步器根据具体场景来定制，如常见的 ReentrantLock 、 RetrantReadWriteLock和CountDownLatch 等等，AQS内容太多，尽量只简明梳理condition相关流程，不太深入理解底层源码。</span>
- public Condition newCondition() {
- return sync.newCondition();
- }
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信号的队列，两个队列的作用是不同，事实上，每个线程也仅仅会同时存在以上两个队列中的一个，流程是这样的：
注意：
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/
1368
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
