并发包学习：线程池之Executor，Executors，ExecutorService

线程池

public interface Executor {

    void execute(Runnable command);
}

Executor没什么说的，线程池顶层接口，只有一个方法execute。

Executors是对线程执行的工具类，可以看做是线程的工厂，用来产生各种线程池

简单复习下

带缓存的，可以看到，存活时间60s，60s没用到就会被回收，
队列是SynchronousQueue，来一个线程之前必须得走一个，不然就阻塞
没有线程工厂就用默认的
拒绝策略也是默认的。不用指定  
 public static ExecutorService newCachedThreadPool() {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>());
    }

  public static ExecutorService newCachedThreadPool(ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
                                      60L, TimeUnit.SECONDS,
                                      new SynchronousQueue<Runnable>(),
                                      threadFactory);
    }



指定固定大小的线程池，没啥说的

public static ExecutorService newFixedThreadPool(int nThreads) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>());
    }

public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory) {
        return new ThreadPoolExecutor(nThreads, nThreads,
                                      0L, TimeUnit.MILLISECONDS,
                                      new LinkedBlockingQueue<Runnable>(),
                                      threadFactory);
    }



定时的，这里有区别，她是new ScheduledThreadPoolExecutor这个的，这个类以后细看吧，
主要是使用的队列是DelayedWorkQueue这个
参数是核心线程数

 public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
        return new ScheduledThreadPoolExecutor(corePoolSize);
    }

    
    public static ScheduledExecutorService newScheduledThreadPool(
            int corePoolSize, ThreadFactory threadFactory) {
        return new ScheduledThreadPoolExecutor(corePoolSize, threadFactory);
    }



还有一个是单例的，就是只有一个线程，为什么会有单个线程的线程池呢，因为线程池是有任务队列的
生命周期管理线程池可以帮你提供的。

 

ExecutorService

ExecutorService继承于Executor，它提供一些可以管理任务的执行、取消、结束的方法。

shutdown方法

void shutdown();

shutdown方法调用之后，马上拒绝接收新的任务，但是之前已经提交的任务会继续执行。

shutdownNow方法

List<Runnable> shutdownNow();

该函数调用之后，马上拒绝接收新的任务，并且会尝试结束当前正在执行的任务，直到所有任务真正结束为止，并且会返回等待执行的任务的列表。

isShutdown方法

boolean isShutdown();

该函数判断service是否已经被shutdown，如果调用过shutdown函数，则返回true，否则返回false。

isTerminated方法

boolean isTerminated();

该函数判断service中得所有任务是否已经全部执行完毕，并且应该注意的是：如果没有调用过shutdown函数或者shutdownNow函数，该函数的返回值不可能为true。

awaitTermination方法

boolean awaitTermination(long timeout, TimeUnit unit) throws InterruptedException;

该函数会一直阻塞直到所有的任务已经被执行或者等待时间到。

submit方法

<T> Future<T> submit(Callable<T> task);

<T> Future<T> submit(Runnable task, T result);

Future<?> submit(Runnable task);

这些函数都是向service提交一个任务，并且返回一个Futrue对象，用于追踪任务的执行情况。区别在于第一个函数在任务执行完毕之后Futrue.get()将会返回任务执行的结果，第二个函数在任务执行完毕之后Future.get()将会返回给定的result结果，而第三个函数在任务执行完毕之后Future.get()将会返回null。

invokeAll方法

<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;

这些方法比较好理解，就是执行任务列表中的所有任务，并返回与每个任务对应的Futue。也就是说，任务彼此之间不会相互影响，可以通过future跟踪每一个任务的执行情况，比如是否被取消，是正常完成，还是异常完成，这主要使用Future类提供的API。invokeAll是一个阻塞方法，会等待任务列表中的所有任务都执行完成。不管任务是正常完成，还是异常终止，Future.isDone()始终返回true。通过
Future.isCanceled()可以判断任务是否在执行的过程中被取消。通过Future.get()可以获取任务的返回结果，或者是任务在执行中抛出的异常。

invokeAny方法

<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;

上面的函数执行给定的一系列任务，当某一个任务成功执行（没有抛出异常）时，返回该任务对应的Future对象，其他所有未被执行的任务都将取消。如果执行过程中修改了tasks列表，则返回的结果是不确定的。第二个函数带有超时时间。此外还应该注意：

• 一旦有1个任务正常完成(执行过程中没有抛异常)，线程池会终止>其他未完成的任务 。
• 如果提交的任务列表中，没有1个正常完成的任务，那么调用invokeAny会抛异常，究竟抛的是哪儿个任务的异常，无关紧要
• invokeAny()和任务的提交顺序无关，只是返回最早正常执行完成的任务
• 如果在超时之前，所有任务已经都是异常终止，那就没有必要在等下去了；如果超时之后，仍然有正在运行或等待运行的任务，那么会抛出TimeoutException。