欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

ExecutorService的方法分析

程序员文章站 2022-07-14 22:57:12
...

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