并发编程--线程池Executor（一）

迷南。 2022-06-12 06:56 212阅读 0赞

合理利用线程池能够带来三个好处。第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。第二：提高响应速度。当任务到达时，任务可以不需要的等到线程创建就能立即执行。第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。但是要做到合理的利用线程池，必须对其原理了如指掌。

线程池的架构图如下：

[![07231601-3ee0f7defe5847289e6e308d1d312ed1.jpg][]][07231601-3ee0f7defe5847289e6e308d1d312ed1.jpg]

**1. Executor**

它是"执行者"接口，它是来执行任务的。准确的说，Executor提供了execute()接口来执行已提交的 Runnable 任务的对象。Executor存在的目的是提供一种将"任务提交"与"任务如何运行"分离开来的机制。  
它只包含一个函数接口：

void execute(Runnable command)

**2. ExecutorService**

ExecutorService继承于Executor。它是"执行者服务"接口，它是为"执行者接口Executor"服务而存在的；准确的话，ExecutorService提供了"将任务提交给执行者的接口(submit方法)"，"让执行者执行任务(invokeAll, invokeAny方法)"的接口等等。

public interface ExecutorService extends Executor {
    
    	// 启动一次顺序关闭，执行以前提交的任务，但不接受新任务。
        void shutdown();
    
        // 试图停止所有正在执行的活动任务，暂停处理正在等待的任务，并返回等待执行的任务列表。
        List<Runnable> shutdownNow();
    
       // 如果关闭后所有任务都已完成，则返回 true。
        boolean isShutdown();
    
    	//判断在关闭之后所有任务十分都已完成
        boolean isTerminated();
    
       // 请求关闭、发生超时或者当前线程中断，无论哪一个首先发生之后，都将导致阻塞，直到所有任务完成执行。
        boolean awaitTermination(long timeout, TimeUnit unit)
            throws InterruptedException;
    	// 提交一个返回值的任务用于执行，返回一个表示任务的未决结果的 Future。
        <T> Future<T> submit(Callable<T> task);
    
       // 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。
        <T> Future<T> submit(Runnable task, T result);
    
        // 提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。
        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;
    
        // 执行给定的任务，当所有任务完成或超时期满时（无论哪个首先发生），返回保持任务状态和结果的 Future 列表。
        <T> T invokeAny(Collection<? extends Callable<T>> tasks,
                        long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException;
    }

**3. AbstractExecutorService**

AbstractExecutorService是一个抽象类，它实现了ExecutorService接口。  
AbstractExecutorService存在的目的是为ExecutorService中的函数接口提供了默认实现。

**AbstractExecutorService函数列表**  
由于它的函数列表和ExecutorService一样，这里就不再重复列举了。

**4. ThreadPoolExecutor**

ThreadPoolExecutor就是大名鼎鼎的"线程池"。它继承于AbstractExecutorService抽象类。

**5. ScheduledExecutorService**

ScheduledExecutorService是一个接口，它继承于于ExecutorService。它相当于提供了"延时"和"周期执行"功能的ExecutorService。  
ScheduledExecutorService提供了相应的函数接口，可以安排任务在给定的延迟后执行，也可以让任务周期的执行。

public interface ScheduledExecutorService extends ExecutorService {
    
        // 创建并执行在给定延迟后启用的 ScheduledFuture。
        public ScheduledFuture<?> schedule(Runnable command,
                                           long delay, TimeUnit unit);
    
       // 创建并执行在给定延迟后启用的一次性操作。
        public <V> ScheduledFuture<V> schedule(Callable<V> callable,
                                               long delay, TimeUnit unit);
    								
    	// 创建并执行一个在给定初始延迟后首次启用的定期操作，后续操作具有给定的周期；也就是将在 initialDelay 后开始执行，然后在 initialDelay+period 后执行，接着在 initialDelay + 2 * period 后执行，依此类推。								
        public ScheduledFuture<?> scheduleAtFixedRate(Runnable command,
                                                      long initialDelay,
                                                      long period,
                                                      TimeUnit unit);
    												  
    	// 创建并执行一个在给定初始延迟后首次启用的定期操作，随后，在每一次执行终止和下一次执行开始之间都存在给定的延迟。											  
        public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
                                                         long initialDelay,
                                                         long delay,
                                                         TimeUnit unit);
    
    }

**6. ScheduledThreadPoolExecutor**

ScheduledThreadPoolExecutor继承于ThreadPoolExecutor，并且实现了ScheduledExecutorService接口。它相当于提供了"延时"和"周期执行"功能的ScheduledExecutorService。  
ScheduledThreadPoolExecutor类似于Timer，但是在高并发程序中，ScheduledThreadPoolExecutor的性能要优于Timer。

**7. Executors**

Executors是个静态工厂类。它通过静态工厂方法返回ExecutorService、ScheduledExecutorService、ThreadFactory 和 Callable 等类的对象。

参考：http://www.cnblogs.com/skywang12345/p/3509903.html

[07231601-3ee0f7defe5847289e6e308d1d312ed1.jpg]: /images/20220612/ed8d620ef010410a98b086f8b8961006.png