Java多线程17：使用Condition实现等待/通知

前言

关键字synchronized与wait()和notify()/notifyAll()方法相结合可以实现等待/通知模式，类ReentrantLock也可以实现同样的功能，但需要借助Condition对象。Condition类是在JDK5中出现的技术，使用它有更好的灵活性，比如可以实现多路通知功能，也就是在一个Lock对象里面可以创建多个Condition（即对象监视器）实例，线程对象可以注册在指定的Condition中，从而可以有选择性地进行线程通知，在调度线程上更加灵活。
在使用notify()/notifyAll()方法进行通知时，被通知的线程却是有JVM随机选择的。但使用ReentrantLock结合Condition类是可以实现前面介绍过的“选择性通知”，这个功能是非常重要的，而且在Condition类中是默认提供的。
而synchronized就相当于整个Lock对象中只有一个单一的Condition对象，所有的线程都注册在它一个对象的身上。线程开始notifyAll()时，需要通知所有的WAITING线程，没有选择权，会出现相当大的效率问题。

1、使用ReentrantLock类的newCondition()方法可以获取Condition对象。
2、需要等待的时候使用Condition的await()方法，唤醒的时候用signal()方法。
3、不同的线程使用不同的Condition，这样就能区分唤醒的时候找哪个线程。

在多线程中单独唤醒某个线程，这时就有必要使用多个Condition对象了，也就是Condition对象可以唤醒部分线程，有助于提升程序的运行效率。可以先对线程进行分组，然后再唤醒指定组中的线程。

package unit3;

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

public class Demo7_Run {
	public static void main(String[] args) throws InterruptedException {
		MyService1 service = new MyService1();
		ThreadA a = new ThreadA(service);
		a.setName("A");
		a.start();
		ThreadB b = new ThreadB(service);
		b.setName("B");
		b.start();
		Thread.sleep(3000);
		service.singalAll_A();
		//service.signalAll_B();
	}
}

class ThreadA extends Thread {
	private MyService1 service;
	public ThreadA(MyService1 service) {
		super();
		this.service = service;
	}
	public void run() {
		service.awaitA();
	}
}

class ThreadB extends Thread {
	private MyService1 service;
	public ThreadB(MyService1 service) {
		super();
		this.service = service;
	}
	public void run() {
		service.awaitB();
	}
}

class MyService1 {
	private Lock lock = new ReentrantLock();
	public Condition conditionA = lock.newCondition();
	public Condition conditionB = lock.newCondition();
	public void awaitA() {
		try {
			lock.lock();
			System.out.println("begin awaitA时间为 " + System.currentTimeMillis()
			+ " ThreadName=" + Thread.currentThread().getName());
			conditionA.await();
			System.out.println(" end awaitA时间为" + System.currentTimeMillis() +
					" ThreadName=" + Thread.currentThread().getName());
		} catch(InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void awaitB() {
		try {
			lock.lock();
			System.out.println("begin awaitB时间为" + System.currentTimeMillis()
					+ " ThreadName=" + Thread.currentThread().getName());
			conditionB.await();
			System.out.println(" end awaitB时间为" + System.currentTimeMillis() +
					" ThreadName=" + Thread.currentThread().getName());
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			lock.unlock();
		}
	}
	
	public void singalAll_A() {
		try {
			lock.lock();
			System.out.println(" signalAll_A时间为" + System.currentTimeMillis()
				+ " ThreadName=" + Thread.currentThread().getName());
			conditionA.signalAll();
		} finally {
			lock.unlock();
		}
	}
	public void signalAll_B() {
		try {
			lock.lock();
			System.out.println(" signalAll_B时间为 " + System.currentTimeMillis()+
				" ThreadName=" + Thread.currentThread().getName());
			conditionB.signalAll();
		} finally {
			lock.unlock();
		}
	}
}

运行结果如下：

使用Condition实现顺序执行

package unit4;

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

public class Demo3_Condition {
	volatile private static int nextPrintWho = 1;
	private static ReentrantLock lock = new ReentrantLock();
	final private static Condition conditionA = lock.newCondition();
	final private static Condition conditionB = lock.newCondition();
	final private static Condition conditionC = lock.newCondition();
	public static void main(String[] args) {
		Thread threadA = new Thread(){
			public void run() {
				try {
					lock.lock();
					while (nextPrintWho != 1) {
						conditionA.await();
					}
					/*for (int i = 0; i < 3; i++) {
						System.out.println("ThreadA " + (i + 1));
					}*/
					System.out.println("A");
					nextPrintWho = 2;
					conditionB.signalAll();
				} catch (Exception e) {
					e.printStackTrace();
				} finally {
					lock.unlock();
				}
			}
		};
		Thread threadB = new Thread(){
			public void run() {
				try {
					lock.lock();
					while (nextPrintWho != 2) {
						conditionA.await();
					}
					/*for (int i = 0; i < 3; i++) {
						System.out.println("ThreadB " + (i + 1));
					}*/
					System.out.println("B");
					nextPrintWho = 3;
					conditionC.signalAll();
				} catch (Exception e) {
					e.printStackTrace();
				} finally {
					lock.unlock();
				}
			}
		};
		Thread threadC = new Thread(){
			public void run() {
				try {
					lock.lock();
					while (nextPrintWho != 3) {
						conditionA.await();
					}
					/*for (int i = 0; i < 3; i++) {
						System.out.println("ThreadC " + (i + 1));
					}*/
					System.out.println("C");
					nextPrintWho = 1;
					conditionA.signalAll();
				} catch (Exception e) {
					e.printStackTrace();
				} finally {
					lock.unlock();
				}
			}
		};
		Thread[] aArray = new Thread[5];
		Thread[] bArray = new Thread[5];
		Thread[] cArray = new Thread[5];
		for (int i = 0; i < 5; i++) {
			aArray[i] = new Thread(threadA);
			bArray[i] = new Thread(threadB);
			cArray[i] = new Thread(threadC);
			aArray[i].start();
			bArray[i].start();
			cArray[i].start();
		}
		
	}
}

执行结果如下：