玩转并发-Executors框架

从Executor谈起

Executor该接口的目的是解耦任务本身和任务的执行。

public interface Executor {
	//Executor接口中只包含execute方法，该方法传入实现了Runnable接口的类
    void execute(Runnable command);
}

Executor仅仅是一个接口，根据子类的不同实现，执行任务的具体方式也不同

增强的Executor——ExecutorService

ExecutorService继承自Executor，在Executor的基础上增强了对任务的控制，同时增加了对自身生命周期的管理

关闭执行器，禁止任务的提交
监视执行器的状态
提供对异步任务的支持
提供对批处理任务的支持

public interface ExecutorService extends Executor {
	/**
	*关闭执行器-平滑关闭
	*1.已经提交给该执行器的任务将会继续执行，但是不再接收新任务的提交
	*2.如果执行器已经关闭，则再次调用没有副作用
	*/
    void shutdown();
	
	/**
	*立即关闭执行器
	*1.尝试所有正在执行的任务，无法保证能够停止成功，但会尽力尝试
	*2，暂停处理已经提交但仍未执行的任务
	*return：返回已经提交但仍未执行的任务列表
	*/
    List<Runnable> shutdownNow();

	/**
	*若执行器已经关闭，返回true
	*/
    boolean isShutdown();
	
	/**
	*执行器是否终止
	*仅当执行器已关闭且所有任务都已经执行完成，才返回true
	*除非首先调用shutdown()或shutdownNow()，否则该方法永远返回false
	*/
    boolean isTerminated();

	/**
	*阻塞调用线程，等待执行器到达终止状态
	*return:如果该执行器最终到达终止状态，则返回true
	*/
    boolean awaitTermination(long timeout, TimeUnit unit)
        throws InterruptedException;

	/**
	*提交一个具有返回值的任务用于执行
	*task实现回调接口
	return：返回Future
	*/
    <T> Future<T> submit(Callable<T> task);

	/**
	*提交一个Runnable任务用于执行
	*@param result：返回结果
	*/
    <T> Future<T> submit(Runnable task, T result);

    Future<?> submit(Runnable task);
	
	/**
	*执行给定集合中的任务
	*当所有任务都执行完，返回保持任务状态和结果的Future列表
	*/
    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks)
        throws InterruptedException;

    <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks,
                                  long timeout, TimeUnit unit)
        throws InterruptedException;

    <T> T invokeAny(Collection<? extends Callable<T>> tasks)
        throws InterruptedException, ExecutionException;

    <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                    long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}

周期任务调度——ScheduledExecutorService

在工业环境中，我们可能希望提交给执行器的某些任务能够定时执行或周期性地执行，Doug Lea已经考虑到了这类需求，所以在ExecutorService的基础上，又提供了一个接口——ScheduledExecutorService

public interface ScheduledExecutorService extends ExecutorService {

    /**
    *提交一个待执行的任务，在给定延迟后执行该任务
    *
    */
    public ScheduledFuture<?> schedule(Runnable command,
                                       long delay, TimeUnit unit);

 	/**
 	*提交一个待执行的任务(具有返回值)，并在给定延迟后执行该任务
 	*/
    public <V> ScheduledFuture<V> schedule(Callable<V> callable,
                                           long delay, TimeUnit unit);

	/**
    *提交一个待执行的任务，在给定延迟后执行该任务
    *按照周期period执行
    */
    public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                  long initialDelay,
                                                  long period,
                                                  TimeUnit unit);

   
    public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                     long initialDelay,
                                                     long delay,
                                                     TimeUnit unit);

}

三个类之间的关系
玩转并发-Executors框架

生产executor的工厂

Executors框架就是用来解耦任务本身和任务执行的，并提供了三个核心接口来满足使用者的需求：

Executor：提交普通的可执行任务
ExecutorService：提供对线程池生命周期的管理，异步任务的支持
ScheduledExecutorService：提供对任务的周期性执行支持

JUC下还提供了一个Executors类，专门用于创建上述接口的实现对象。Executors就是一个简单工厂，所有方法都是static。Executors一共提供了五类可供Executor执行器的实例.
Executor执行器实例的创建涉及ThreadPoolExecutor详解ThreadPoolExecutor

/**
 * 创建一个具有固定线程数的Executor.
 */
public static ExecutorService newFixedThreadPool(int nThreads) {
    return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>());
}

/**
 * 创建一个具有固定线程数的Executor.
 * 在需要时使用提供的 ThreadFactory 创建新线程.
 */
public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
    return new ThreadPoolExecutor(nThreads, nThreads, 0L, TimeUnit.MILLISECONDS,
            new LinkedBlockingQueue<Runnable>(), threadFactory);

}

小结

玩转并发-Executors框架

Executor：执行器接口
ExecutorService：在Executor的基础上提供了执行器的生命周期管理，任务异步执行等功能
ScheduledExecutorService：在Excutor的基础上提供了任务的延迟执行/周期执行的功能
Excutors：生产具体的执行器静态工厂
ThreadFactory：线程工程，用于创建单个线程
AbstractExcutorService：ExecutorService的抽象实现，为各类执行器的实现提供基础
ThreadPoolExcutor：最常用的Excutor，以线程池的方式管理线程
…

玩转并发-Executors框架

从Executor谈起

增强的Executor——ExecutorService

周期任务调度——ScheduledExecutorService

生产executor的工厂

小结

相关推荐