Java多线程Future模式

package future;

import java.util.Date;

/**
 * 服务器
 * 
 * @author wpy
 * 
 */
public class Service {
	/**
	 * 1.服务器的处理某个业务，该业务可以分成AB两个过程，并且AB两个过程之间不需要彼此的返回结果
	 * 2.A过程需要1秒钟，B过程需要2秒钟，主线程其他操作2秒钟
	 * 
	 * @param args
	 * @throws InterruptedException
	 */
	public static void main(String[] args) throws InterruptedException {
		Service service = new Service();
		long notUseFuture = service.notUseFuture();
		
		System.out.println("==============================");
		long useFuture = service.useFuture();
		
		System.out.println("==============================");
		System.out.println("notUseFuture整个业务耗时"+notUseFuture);
		System.out.println("useFuture整个业务耗时"+useFuture);
	}

	public long useFuture() throws InterruptedException {
		Date startOn = new Date();

		String name = Thread.currentThread().getName();
		final FutureDate<String> futureDateA = new FutureDate<>();
		final FutureDate<String> futureDateB = new FutureDate<>();

		Thread a = new Thread(new Runnable() {

			@Override
			public void run() {
				String name = Thread.currentThread().getName();
				System.out.println(name + ":任务A开始执行");
				try {
					Thread.sleep(1000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				futureDateA.setData(name + ":任务A执行结果");
				System.out.println(name + ":任务A执行结束");
			}
		}, "线程A");

		Thread b = new Thread(new Runnable() {

			@Override
			public void run() {
				String name = Thread.currentThread().getName();
				System.out.println(name + ":任务B开始执行");
				try {
					Thread.sleep(3000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				futureDateB.setData(name + ":任务B执行结果");
				System.out.println(name + ":任务B执行结束");
			}
		}, "线程B");

		Date before = new Date();
		a.start();
		b.start();
		Date after = new Date();
		System.out.println(name + ":a,b阻塞主线程时间:"
				+ (after.getTime() - before.getTime()));

		// 假设其他业务执行两秒钟
		Thread.sleep(2000);

		before = new Date();
		String dataA = futureDateA.getData();
		after = new Date();
		System.out.println(name + ":获取A线程结果时间:"
				+ (after.getTime() - before.getTime()));

		before = new Date();
		String dataB = futureDateB.getData();
		after = new Date();
		System.out.println(name + ":获取线程结果时间:"
				+ (after.getTime() - before.getTime()));

		System.out.println(name + ":A线程结果：" + dataA);
		System.out.println(name + ":B线程结果：" + dataB);
		Date endOn = new Date();

		/*System.out.println(name + "整个业务耗时"
				+ (endOn.getTime() - startOn.getTime()));*/
		return endOn.getTime() - startOn.getTime();
	}

	public long notUseFuture() throws InterruptedException {
		Date startOn = new Date();

		// 任务A
		String name = Thread.currentThread().getName();
		System.out.println(name + ":任务A开始执行");
		Thread.sleep(1000);
		System.out.println(name + ":任务A执行结束");

		// 任务B
		System.out.println(name + ":任务B开始执行");
		Thread.sleep(3000);
		System.out.println(name + ":任务B执行结束");

		// 主线程其他操作
		Thread.sleep(2000);

		Date endOn = new Date();
		return endOn.getTime() - startOn.getTime();
	}
}

package future;

/**
 * 用户获取异步任务执行结果
 * @author wpy
 *
 */
public class FutureDate<T> {
	private boolean isReady = false;
	private T data;
	
	/**
	 * 异步任务执行完毕后会通过此方法将执行结果传递给data;
	 * @param data
	 */
	public synchronized void setData(T data){
		if(isReady){
			return;
		}
		this.data = data;
		isReady = true;
		notify();
	}
	
	/**
	 * 如果数据没有加载完毕，线程积蓄等待
	 * wait()会释放锁
	 * @return
	 * @throws InterruptedException
	 */
	public synchronized T getData() throws InterruptedException{
		if(!isReady){
			wait();
		}
		return data;
	}
	
	
}