java并发编程 之 Condition（等待和通知）

Condition的功能类似在传统线程技术中的Object.wait和Object.notity的功能。一个锁内部可以有多个Condition，即有多路等待和通知，可以参看Jdk1.5提供的Lock和Condition实现的可阻塞队列的应用案例。在传统的线程机制中一个监视器对象上只能有一路等待和通知，要想实现多路等待和通知，必须嵌套使用多个同步监视器对象。
例一：
JDK文档中提供了一个很不错的示例（http://docs.oracle.com/javase/6/docs/api/ ），用Condition实现一个阻塞队列，代码如下：

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;



public 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();

        }

    }

}

例二：
三个线程 循环打印 ： 线程1唤醒线程2，线程2唤醒线程3，线程3唤醒线程1。

package com.huang.test;

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

/**
 * java 条件阻塞——condition
 * 三个线程 循环打印 ： 线程1唤醒线程2，线程2唤醒线程3，线程3唤醒线程1
 * @author wuseyukui
 *
 */
public class ThreadTest {

private boolean isMainRun = true;
private boolean isSub1Run = false;
private boolean isSub2Run = false;
private Lock lock = new ReentrantLock();
private Condition condition1 = lock.newCondition();
private Condition condition2 = lock.newCondition();
private Condition condition3 = lock.newCondition();

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

private void init() {
new ThreadMain().start();
new ThreadSon1().start();
new ThreadSon2().start();
    }

    class ThreadMain extends Thread {
@Override
public void run() {
for (int i = 1; i < 6; i++) {
                main(i);
            }
        }

    }

    class ThreadSon1 extends Thread {
@Override
public void run() {
for (int i = 1; i < 6; i++) {
                sub1(i);
            }
        }
    }

    class ThreadSon2 extends Thread {
@Override
public void run() {
for (int i = 1; i < 6; i++) {
                sub2(i);
            }
        }
    }

private /*synchronized*/ void main(int i) {
        lock.lock();
while (!isMainRun) {
try {
// wait();
                condition1.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
for (int j = 0; j < 10; j++) {
            System.out.println(" 主线程打印：" + (j + 1) + "，第" + i + "个循环");
        }

        isSub1Run = true;
        isMainRun = false;
        condition2.signal();
// notify();
        lock.unlock();
    }

private /*synchronized*/ void sub1(int i) {
        lock.lock();
while (!isSub1Run) {
try {
// wait();
                condition2.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
for (int j = 0; j < 20; j++) {
            System.out.println(" 子线程1打印：" + (j + 1) + "，第" + i + "个循环");
        }

        isSub2Run = true;
        isSub1Run = false;
        condition3.signal();
// notify();
        lock.unlock();
    }

private /*synchronized*/ void sub2(int i) {
        lock.lock();
while (!isSub2Run) {
try {
// wait();
                condition3.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
for (int j = 0; j < 20; j++) {
            System.out.println(" 子线程2打印：" + (j + 1) + "，第" + i + "个循环");
        }

        isMainRun = true;
        isSub2Run = false;
        condition1.signal();
// notify();
        lock.unlock();
    }

}