ExecutorService的方法分析

ExecutorService接口继承了Executor接口其主要方法如下：

/**
	 * 优雅地关闭：先前提交的任务会继续执行完成，但不接受新的任务<br>
	 * 对于已关闭的ExecutorService没有影响
	 */
	void shutdown();

	/**
	 * 强行关闭：试图停止所有正在执行的任务，挂起等待执行的任务，返回等待执行任务的清单，而不是被中断任务的清单<br>
	 * 不能保证停止当前的任务会成功：典型的实现是通过调用Thread.interrupt()方法，所以不能回应该方法的任务将无法关闭
	 */
	List<Runnable> shutdownNow();

	/**
	 * 判断线程池是否已关闭<br>
	 * 在调用了shutdown()或shutdownNow()方法后，该方法返回true，此时线程池可能并未终止，调用isTerminated()
	 * 为false
	 * 
	 * @return
	 */
	boolean isShutdown();

	/**
	 * 判断线程池是否终止。只有调用shutdown()或shutdownNow()一定时间后，该方法才可能返回true
	 * 
	 * @return
	 */
	boolean isTerminated();

	/**
	 * 等待线程池终止。在所有任务执行完成，或者超时，或者当前线程被中断前，该方法一直阻塞
	 * 
	 * @param timeout
	 * @param unit
	 * @return
	 * @throws InterruptedException
	 */
	boolean awaitTermination(long timeout, TimeUnit unit)
			throws InterruptedException;

	/**
	 * 提交一个有返回结果的任务。如果成功完成，Future的get()方法会返回执行结果<br>
	 * Executors包含一系列方法，能够把其它普通的closure-like对象，转化成可以执行的Callable对象
	 * 
	 * @param <T>
	 * @param task
	 * @return
	 */
	<T> Future<T> submit(Callable<T> task);

	/**
	 * 提交一个有返回结果的任务。Runnable没有返回值，我们可以提供个预设值result，如果任务成功完成，将返回该result
	 * 
	 * @param <T>
	 * @param task
	 * @param result
	 * @return
	 */
	<T> Future<T> submit(Runnable task, T result);

	/**
	 * 提交一个有返回结果的任务。如果成功完成，Future.get()返回null。
	 * 
	 * @param task
	 * @return
	 */
	Future<?> submit(Runnable task);

	/**
	 * 执行指定的任务集，所有的任务完成后，返回一个保存了每个执行结果的Future集(可能是正常完成或者抛出异常)
	 * 
	 * @param <T>
	 * @param tasks
	 * @return
	 * @throws InterruptedException
	 *             被中断，没有完成的任务会被取消
	 * @throws NullPointerException
	 *             tasks为null，或者里面的元素为null
	 * @throws RejectedExecutionException
	 *             某个任务被拒绝执行
	 */
	<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
			throws InterruptedException;

	/**
	 * 执行指定的任务集，所有的任务完成后，返回一个保存了每个执行结果的Future集(可能是正常完成或者抛出异常)<br>
	 * 有时间限制：超时会返回，未完成的任务会取消
	 * 
	 * @param <T>
	 * @param tasks
	 * @param timeout
	 * @param unit
	 * @return
	 * @throws InterruptedException
	 */
	<T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
			long timeout, TimeUnit unit) throws InterruptedException;

	/**
	 * 执行指定的任务集，有一个任务执行成功后就返回该结果。正常返回或抛异常，没有完成的任务会被取消
	 * 
	 * @param <T>
	 * @param tasks
	 * @return
	 * @throws InterruptedException
	 *             被中断，没有完成的任务会被取消
	 * @throws ExecutionException
	 *             没有任务执行成功
	 */
	<T> T invokeAny(Collection<? extends Callable<T>> tasks)
			throws InterruptedException, ExecutionException;

	/**
	 * 执行指定的任务集，有一个任务执行成功后就返回该结果。正常返回或抛异常，没有完成的任务会被取消<br>
	 * 有时间限制
	 * 
	 * @param <T>
	 * @param tasks
	 * @return
	 * @throws InterruptedException
	 *             被中断，没有完成的任务会被取消
	 * @throws ExecutionException
	 *             没有任务执行成功
	 */
	<T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout,
			TimeUnit unit) throws InterruptedException, ExecutionException,
			TimeoutException;

 下面举例测试其中主要和常用的几个方法：

 首先，我们需要创建一个任务代码，这段任务代码主要是随机生成含有10个字符的字符串

  

/**
 * 随机生成10个字符的字符串
 * 
 * @author hegf
 * @date 2013-8-15 下午10:27:03
 */
public class Task1 implements Callable<String> {

	@Override
	public String call() throws Exception {
		String base = "abcdefghijklmnopqistuvwxyz0123456789";
		Random rand = new Random();
		StringBuffer buffer = new StringBuffer();
		for (int i = 0; i < 10; i++) {
			buffer.append(base.charAt(rand.nextInt(base.length())));
		}
		return buffer.toString();
	}

}

 然后，我们还需要一个长任务，这里我们默认是沉睡10秒

/**
 * 任务睡眠10秒的长任务
 * 
 * @author hegf
 * @date 2013-8-15 下午10:26:54
 */
public class LongTask implements Callable<String> {

	@Override
	public String call() throws Exception {
		TimeUnit.SECONDS.sleep(10);
		return null;
	}

}

 OK，所有前期准备完毕，下面我们就来分析一下ExecutorService接口中和生命周期有关的这些方法：

 

               ExecutorService service = Executors.newFixedThreadPool(4);
		service.submit(new Task1());
		service.submit(new Task1());
		service.submit(new LongTask());
		service.submit(new Task1());

		service.shutdown();
		while (!service.awaitTermination(1, TimeUnit.SECONDS)) {
			System.out.println("线程池未停止");
		}
		System.out.println("线程池已停止");

 这段代码中，我们在第三次提交了一个长任务，这个任务将执行10秒沉睡，紧跟着执行了一次shutdown()方法，假设：这时ExecutorService被立即关闭，下面调用service.awaitTermination(1, TimeUnit.SECONDS)方法时应该返回true，程序执行结果应该只会打印出：“线程池已关闭”。但是，真实的运行结果如下：

线程池未停止
线程池未停止
线程池未停止
线程池未停止
线程池未停止
线程池未停止
线程池未停止
线程池未停止
线程池未停止
线程池已停止

 这说明我们假设错误，service.awaitTermination(1, TimeUnit.SECONDS)每隔一秒监测一次ExecutorService的关闭情况，而长任务正好需要执行10秒，因此会在前9秒监测时ExecutorService为未关闭状态，而在第10秒时已经关闭，因此第10秒时输出：线程池已经关闭。这也验证了shutdown方法关闭ExecutorService的条件。

 

		ExecutorService service = Executors.newFixedThreadPool(3);
		service.submit(new LongTask());
		service.submit(new LongTask());
		service.submit(new LongTask());
		service.submit(new LongTask());
		service.submit(new LongTask());

		List<Runnable> runnables = service.shutdownNow();
		System.out.println(runnables.size());
		while (!service.awaitTermination(1, TimeUnit.SECONDS)) {
			System.out.println("线程池未停止");
		}
		System.out.println("线程池已停止");

  这段代码中，我们限制了线程池的长度是3，提交了5个长任务，这样将有两个任务在工作队列中等待，当我们执行shutdownNow方法时，ExecutorService被立刻关闭，所以在service.awaitTermination(1, TimeUnit.MILLISECONDS)方法校验时返回的是false，因此没有输出：线程池未关闭。而在调用shutdownNow方法时，我们接受到了一个List，这里包含的是在工作队列中等待执行的任务，由于线程池长度为3，且执行的都是长任务，所以当提交了三个任务后线程池已经满了，剩下的两次提交只能在工作队列中等待，因此我们看到runnables的大小为2，结果如下：

2
线程池已停止

 

		ExecutorService service = Executors.newFixedThreadPool(3);
		service.submit(new Task1());
		service.submit(new Task1());
		service.submit(new LongTask());

		service.shutdown();
		System.out.println(System.currentTimeMillis());
		while(!service.isTerminated()){
		}
		System.out.println(System.currentTimeMillis());

 这段代码我们执行了两个正常的任务和一个长任务，然后调用了shutdown方法，我们知道调用shutdown方法并不会立即关闭ExecutorService，这时我们记录一下监测循环执行前的时间，在没有关闭前我们一直进入一个空循环中，直到 ExecutorService关闭后退出循环，这里我们知道长任务执行时间为10秒，我们看一下上述程序运行结果：

1376579188593
1376579198593

 这10秒正好是长任务执行的时间，因此在 ExecutorService正常关闭后isTerminated方法返回true