package com.starit.open.main;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * 
 * @author wenin819
 * 
 *         Callable 和 Future接口
 *         Callable是类似于Runnable的接口，实现Callable接口的类和实现Runnable的类都是可被其它线程执行的任务。
 *         Callable和Runnable有几点不同： 
 *         （1）Callable规定的方法是call()，而Runnable规定的方法是run().
 *         （2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值的。
 *         （3）call()方法可抛出异常，而run()方法是不能抛出异常的。 
 *         （4）运行Callable任务可拿到一个Future对象，
 *         Future 表示异步计算的结果。它提供了检查计算是否完成的方法，以等待计算的完成，并检索计算的结果。
 *         通过Future对象可了解任务执行情况，可取消任务的执行，还可获取任务执行的结果。
 * 
 */
public class CallableThreadSync implements Runnable{
	
	private static final ExecutorService es = Executors.newFixedThreadPool(5);
	
	public static class ItemThread implements Callable<Integer> {
		public int addNum;
		public ItemThread(int addNum) {
			this.addNum = addNum;
		}
		
		@Override
		public Integer call() {
			try {
				Thread.sleep(addNum * 1000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
			return addNum * 2;
		}
	}
	
	public static void main(String[] args) {
		CallableThreadSync test = new CallableThreadSync();
		long startTime = System.currentTimeMillis();
		new Thread(test, "thread1").start();
		new Thread(test, "thread2").start();
		long endTime = System.currentTimeMillis();
		System.out.println("main:用时" + (endTime - startTime) / 1000 + "秒");
	}

	public void run() {
		long startTime = System.currentTimeMillis();
		List<ItemThread> itemThreads = new ArrayList<CallableThreadSync.ItemThread>(3);
		ItemThread itemThread = null;
		for(int i = 0; i < 3; i++) {
			itemThread = new ItemThread(i + 1);
			itemThreads.add(itemThread);
		}
		List<Future<Integer>> futureList = null;
		try {
			futureList = es.invokeAll(itemThreads);
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		}
		Integer result = 1;
		for(Future<Integer> future : futureList) {
				try {
					result += future.get();
				} catch (InterruptedException e) {
					e.printStackTrace();
				} catch (ExecutionException e) {
					e.printStackTrace();
				}
		}
		String infoMsg = Thread.currentThread().getName() + ":";
		long endTime = System.currentTimeMillis();
		System.out.println(infoMsg + result + "(用时" + (endTime - startTime) / 1000 + "秒)");
	}
	
	@Override
	protected void finalize() throws Throwable {
		es.shutdownNow();
		super.finalize();
	}

}