java并发编程系列之Condition的使用

Condition是做什么用的了？Condition是用来实现线程间通信的，说到这，可能很多人都想到了wait和notify以及notifyAll，没错，Condition的功能和他们类似，只是功能更强而已，下面我们就来学习一下线程间通过Condition来实现通信。

Condition也是jdk1.5并发包下的一个接口，原型如下：

public interface Condition {
    // 相当于Object的wait方法
    void await() throws InterruptedException;
    void awaitUninterruptibly();
long awaitNanos(long nanosTimeout) throws InterruptedException;
// 在给定的时间，阻塞
    boolean await(long time, TimeUnit unit) throws InterruptedException;
boolean awaitUntil(Date deadline) throws InterruptedException;
// 相当于Object的notify方法
void signal();
// 相当于Object的notifyAll方法
    void signalAll();
}

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()。

下面用官网上的一个示例来说明Condition的使用，代码如下：

public class ConditionDemo {
	// 可重入锁
	final Lock lock = new ReentrantLock();
	// 写线程条件
	final Condition notFull  = lock.newCondition();
	// 读线程条件
	final Condition notEmpty = lock.newCondition();
	// 缓存队列的深度
	final Object[] items = new Object[100];
	// 写索引
	int putptr = 0;
	// 读索引
	int takeptr = 0;
	// 缓存队列中存在的数据个数
	int count = 0;
	/**
	 * 描述：模拟往队列里面放对象
	 */
	public void put(Object x) throws InterruptedException {
		System.out.println("获取写锁！");
		// 上锁
		lock.lock();
		try {
			/*
			 *  如果当前队列里面的对象个数和队列的深度相同，说明队列已经满了，准备阻塞写线程
			 *  注意，此处用while而不用if，是为了防止假唤醒
			 */
			while (count == items.length){
				System.out.println("队列已满，阻塞写线程!");
				// 阻塞写线程
				notFull.await();
			}
			// 写数据
			System.out.println("写入的数据为："+x);
			items[putptr] = x;
			// 如果当前的写索引和队列的深度相同，说明队列已经写满了，所以需要从索引0开始写数据
			if (++putptr == items.length){
				putptr = 0;
			}
			// 队列中的数据个数递增
			++count;
			// 唤醒读线程
			notEmpty.signal();
		}finally {
			System.out.println("释放写锁!");
			// 释放锁
			lock.unlock();
		}
	}
	
	/**
	 * 描述：模拟从队列里面取对象
	 */
	public Object take() throws InterruptedException {
		System.out.println("获取读锁！");
		// 上锁
		lock.lock();
		try {
			// 如果当前队列里面没有数据，阻塞读线程，此处用while原因同上
			while (count == 0){
				System.out.println("队列为空，阻塞读线程!");
				// 阻塞读线程
				notEmpty.await();
			}
			// 读数据
			Object x = items[takeptr];
			// 如果读索引和队列的深度相同，说明已经读到了队列的最后一个数据，需要从0开始读
			if (++takeptr == items.length){
				takeptr = 0;
			}
			// 队列里面的个数递减
			--count;
			// 唤醒写线程
			notFull.signal();
			// 返回读取的对象
			return x;
		}finally {
			System.out.println("释放读锁！");
			// 释放锁
			lock.unlock();
		}
	}
	
	public static void main(String[] args) {
		final ConditionDemo demo = new ConditionDemo();
		
		// 新建N个写线程，且写比对快
		ExecutorService put = Executors.newCachedThreadPool();
		put.execute(new Runnable() {
			@Override
			public void run() {
				for(int i=0; i<399; i++){
					try {
						demo.put("chhliu"+i);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		});
		
		// 新建N个读线程，读比写慢
		ExecutorService take = Executors.newCachedThreadPool();
		take.execute(new Runnable() {
			@Override
			public void run() {
				while(true){
					try {
						// 模拟长时间读
						Thread.sleep(200);
						String message = (String) demo.take();
						System.out.println("读取的数据为："+message);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		});
	}
}

首先，我们先让写快，读慢，当写的线程将缓存队列写满之后，写线程就会被阻塞，只有当读线程从队列中读取数据之后，写线程才会被唤醒，测试结果如下：

写入的数据为：chhliu98
释放写锁!
获取写锁！
写入的数据为：chhliu99
释放写锁!
获取写锁！
队列已满，阻塞写线程!
获取读锁！
读取的数据为：chhliu0
释放读锁！
写入的数据为：chhliu100
释放写锁!
获取写锁！
队列已满，阻塞写线程!
.......
读取的数据为：chhliu298
释放读锁！
获取读锁！
队列为空，阻塞读线程!
程序首先会一直写数据，直到队列写满，然后会阻塞写线程，唤醒读线程，读线程读取数据之后，队列未满，然后会唤醒写线程，这样依次交替进行，等所有的数据都读取完之后，会阻塞读线程。

从上面的例子中，我们可以看到，我们同时使用了多个Condition，这在传统的线程通信中是不可能看到的现象，假设缓存队列中已经存满，那么阻塞的肯定是写线程，唤醒的肯定是读线程，相反，阻塞的肯定是读线程，唤醒的肯定是写线程，那么假设只有一个 Condition会有什么效果呢，缓存队列中已经存满，这个Lock不知道唤醒的是读线程还是写线程了，如果唤醒的是读线程，皆大欢喜，如果唤醒的是写 线程，那么线程刚被唤醒，又被阻塞了，这时又去唤醒，这样就浪费了很多时间。