【Java多线程与并发库】11.java5条件阻塞Condition的应用

Condition

(1)概述
Condition是Java有关锁的包下面的一个类，锁我们只能实现互斥，不能实现通知。而Condition就是解决这个问题，Condition的功能类似在传统线程技术中的Object.wait和Object.notify的功能。

(2)实例
记得我们之前写过的一个例子，一道面试题:
子线程循环10次，接着主线程循环100次，接着又回到子线程循环10次，
接着再回到主线程又循环100次，如此循环50次。

代码是这样的:

package cn.edu.hpu.test;

public class ThreadTest4 {

    public static void main(String[] args) {
        new ThreadTest4().init();
    }

    public void init()
    {
        final Business business = new Business();
        new Thread(
                new Runnable()
                {

                    public void run() {
                        for(int i=0;i<50;i++)
                        {
                            business.SubThread(i);
                        }                        
                    }
                    
                }
        
        ).start();
        
        for(int i=0;i<50;i++)
        {
            business.MainThread(i);
        }        
    }
    
    private class Business
    {
        boolean bShouldSub = true;//这里相当于定义了控制该谁执行的一个信号灯
        public synchronized void MainThread(int i)
        {
            if(bShouldSub)
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }        
                
            for(int j=1;j<=100;j++)
            {
                System.out.println(Thread.currentThread().getName() + ":i=" + i +",j=" + j);
            }
            bShouldSub = true;
            this.notify();
        
        }
        
        
        public synchronized void SubThread(int i)
        {
            if(!bShouldSub)
                try {
                    this.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }    
                
            for(int j=1;j<=10;j++)
            {
                System.out.println(Thread.currentThread().getName() + ":i=" + i +",j=" + j);
            }
            bShouldSub = false;                
            this.notify();            
        }
    }
}

我们这里要对它进行该写，使用Java5的并发库中的“锁(lock)”和“条件(Condition)”，
来代替原来的“synchronized”和“wait/notify”。
改写后的部分代码:

private class Business
{
    Lock lock = new ReentrantLock();//线程锁对象
    Condition condition = lock.newCondition();//获取锁控制下的状态对象
    
    boolean bShouldSub = true;//这里相当于定义了控制该谁执行的一个信号灯
    public void MainThread(int i)
    {
        lock.lock();//加锁
        try {
            if (bShouldSub)
                try {
                    condition.await();//条件阻塞
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            for (int j = 1; j <= 100; j++) {
                System.out.println(Thread.currentThread().getName() + ":i="
                        + i + ",j=" + j);
            }
            bShouldSub = true;
            condition.signal();//通知其它某个线程
        }finally{
            lock.unlock();//解锁
        }
    
    }
    
    
    public synchronized void SubThread(int i)
    {
        lock.lock();//加锁
        try {
            if(!bShouldSub)
                try {
                    condition.await();//条件阻塞
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }    
                
            for(int j=1;j<=10;j++)
            {
                System.out.println(Thread.currentThread().getName() + ":i=" + i +",j=" + j);
            }
            bShouldSub = false;                
            condition.signal();//通知其它某个线程
        }finally{
            lock.unlock();//解锁
        }
    }
}

运行效果:


在等待Condition时，允许发生“虚假唤醒”，这通常作为对基础平台语义上的让步。对于大多数应用程序，这带来的实际影响很小，因为Condition应该总是在一个循环中被等待，并测试正在被等待的状态声明。某个实现可以随意移除可能的虚假唤醒，但建议应用程序的程序员总是假定这些虚假唤醒可能发生，因此总是在一个循环中等待。

为了防止“虚假唤醒”，所以我们要把上面的

if (bShouldSub)
    try {
        condition.await();//条件阻塞
        } catch (InterruptedException e) {
        e.printStackTrace();
    }
    for (int j = 1; j <= 100; j++) {
        System.out.println(Thread.currentThread().getName() + ":i="
                + i + ",j=" + j);
        }
}

改为

while(bShouldSub)
    try {
        condition.await();//条件阻塞
        } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
for (int j = 1; j <= 100; j++) {
    System.out.println(Thread.currentThread().getName() + ":i="
            + i + ",j=" + j);
}

下面子线程的也是一个道理。

(3)优势
既然condition和原来的this.wait/this.notify实现的效果一样，我干嘛还要使用它呢？
其实condition最重要的一点是，它可以配合lock实现“多路等待”(阻塞/唤醒指定类型的线程)，
实现单一this.wait/this.notify它们实现不了的功能。

我们来看看JavaApi中的一个“可阻塞的队列”的底层代码实现:

作为一个示例，假定有一个绑定的缓冲区，它支持 put 和 take 方法。如果试图在空的缓冲区上执行 take 操作，则在某一个项变得可用之前，线程将一直阻塞；如果试图在满的缓冲区上执行 put 操作，则在有空间变得可用之前，线程将一直阻塞。而唤醒的时候，“取”的唤醒只会唤醒取take线程，
“放”的唤醒只会唤醒put线程。一次只通知一个线程。可以使用两个 Condition 实例来做到这一点。

 class BoundedBuffer {
   final Lock lock = new ReentrantLock();
   final Condition notFull  = lock.newCondition();
   final Condition notEmpty = lock.newCondition();

   final Object[] items = new Object[100];
   int putptr, takeptr, count;

   public void put(Object x) throws InterruptedException {
     lock.lock();
     try {
       while (count == items.length)
         notFull.await();
       items[putptr] = x;
       if (++putptr == items.length) putptr = 0;
       ++count;
       notEmpty.signal();
     } finally {
       lock.unlock();
     }
   }

   public Object take() throws InterruptedException {
     lock.lock();
     try {
       while (count == 0)
         notEmpty.await();
       Object x = items[takeptr];
       if (++takeptr == items.length) takeptr = 0;
       --count;
       notFull.signal();
       return x;
     } finally {
       lock.unlock();
     }
   }
 }

如果只有一个Condition，当唤醒的时候，就会唤醒不必要的线程。

上面的队列起到了“缓冲”的效果，就是在存储空间大小固定的时候，
任务来了很多时，多余的任务就会在队列中等待被拿出使用。而存取都是线程安全

的，不会发生栈溢出和空指针异常的情况。

转载请注明出处：http://blog.csdn.net/acmman/article/details/52918211