android线程池--ThreadPoolExecutor

ThreadPoolExecutor

ThreadPoolExecutor 是线程池的真正实现，它的构造方法提供了一系列参数来配置线程池
这些参数直接影响到线程池的功能特性

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueu,
                          ThreadFactory threadFactory,
                          RejectedExecutionHandler handler)

解释一下参数
corePoolSize ：线程池的核心线程数，核心线程会在线程池中一直存活，即便他们处于闲置状态，如果将ThreadPoolExecutor 的 allowCoreThreadTimeOut 属性设置为true,那么闲置的核心线程在等待新任务到来时会有超时策略，这个时间间隔由keepAliveTime所指定，当等待时间超过keepAliveTime 所指定的时间时，核心线程就会被终止

maximumPoolSize：线程池所能容纳的最大线程数，当活动线程数达到这个数值后，后续的新任务会被堵塞

keepAliveTime：非核心线程闲置时的超出时长，非核心线程就被回收，当ThreadPoolExecutor 的 allowCoreThreadTimeOut 属性设置为true 时，keepAliveTime同样会作用于核心线程

unit：用于指定keepAliveTime 参数的时间单位，这是一个枚举，常用的有TimeUnit.MILLISECONDS(毫秒)、TimeUnit.SECONDS(秒)以及TimeUnit.MINUTES(分钟)等

workQueue：线程池中的任务队列，通过线程池的execute方法提交的Runnable对象会存储在这个参数中

threadFactory：线程工厂，为线程池提供创建新线程的功能，ThreadFactory是一个接口，它只有一个方法：Thread newThread(Runnable r);

handler:当线程池无法执行新任务时，这可能是由于任务队列已满或者是无法执行任务，这个时候ThreadPoolExecutor 会调用 handler 的 rejectedExecution 方法来通知调用者，默认情况下rejectedExecution 方法会直接抛出一个RejectedExecutionException 异常

ThreadPoolExecutor 执行任务时大致遵循如下规则：

1. 如果线程池中的线程数量未达到核心线程的数量，那么会直接启动一个核心线程来执行任务
2. 如果线程池中的线程数量已经达到或者超过核心线程的数量，那么任务会被插入到任务队列中排队等待执行
   3.如果第二步骤中无法将任务插入到任务队列中，这往往是由于任务队列已满，这个时候如果线程数量未达到线程池规定的最大值，那么会立刻启动一个非核心线程来执行任务
   4.如果步骤3中线程数量已经到达线程池规定的最大值，那么就拒绝执行此任务，ThreadPoolExecutor会调用rejectedExecutionHandler 的 rejectedExecution 方法来通知调用者

在AsyncTask 能看到线程池的配置情况

private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
private static final int KEEP_ALIVE = 1;

private static final ThreadFactory sThreadFactory = new ThreadFactory() {
    private final AtomicInteger mCount = new AtomicInteger(1);

    public Thread newThread(Runnable r) {
        return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
    }
};

private static final BlockingQueue<Runnable> sPoolWorkQueue =
        new LinkedBlockingQueue<Runnable>(128);

/**
 * An {@link Executor} that can be used to execute tasks in parallel.
 */
public static final Executor THREAD_POOL_EXECUTOR
        = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

corePoolSize ：线程池的核心线程数等于CPU核心数 + 1；
maximumPoolSize：线程池所能容纳的最大线程数为 CPU核心数的2倍 + 1；
keepAliveTime：非核心线程闲置时的超时时长为1秒，核心线程无超时机制；
unit：用于指定keepAliveTime 参数的时间的单位为TimeUnit.SECONDS（秒）
workQueue：线程池中的任务队列的容量为128；

线程池的分类：

共分为四种：FixedThreadPool 、CachedThreadPool 、 ScheduledThreadPool 、 SingleThreadExecutor

FixedThreadPool:

通过 Executors.newFixedThreadPool(number); 方法创建，它是一种线程数量固定的线程池，当线程处于空闲状态时，它们并不会被回收，除非线程池被关闭了。当所有的线程都处于活动状态时，新任务都会处于等待状态，直到有线程空闲出来。由于 FixedThreadPool只有核心线程并且这些核心线程不会被回收，这意味着它能够更加速地响应外界的请求。
源码：

public static ExecutorService newFixedThreadPool(int nThreads) {

        return new ThreadPoolExecutor(nThreads, nThreads,
                  0L, TimeUnit.MILLISECONDS, newLinkedBlockingQueue<Runnable>());
                  }

CachedThreadPool：

通过Executors.newCachedThreadPool();方法创建。它是一种线程数量不定的线程池，它只有非线程，并且其最大线程数为Integer.MAX_VALUE,由于Integer.MAX_VALUE是一个很大的数，实际上就相当于最大的线程数可以任意大，如果线程池中的线程都处于活动状态时，线程池会创建新的线程处理新任务，否则就会利用空闲的线程来处理新任务，线程池中的线程都会有超时机制，时长为60秒，超过这个时间闲置的线程就会被回收，和FixedThreadPool不同是，CachedThreadPool的任务队列其实相当于一个空集合，这类线程池比较时候执行大量的耗时较少的任务，当整个线程池都处于闲置状态时，线程池中的线程都会超时而被停止，这个时候CachedThreadPool中实际上是没有任何线程的，它几乎是不占用任何系统资源的
源码：

public static ExecutorService newCachedThreadPool() {

        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

                                      60L, TimeUnit.SECONDS,

                                      new SynchronousQueue<Runnable>());

    }

ScheduledThreadPool

通过Executors.newScheduledThreadPool(number); 方法来创建，它的核心线程数是固定的，而非核心线程数是没有限制的，并且当非核心线程闲置时会被立即回收，ScheduledThreadPool这类线程池主要用于执行定时任务和具有固定周期的重复任务
源码：

public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {

        return new ScheduledThreadPoolExecutor(corePoolSize);

    }

public ScheduledThreadPoolExecutor(int corePoolSize) {

        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,

              new DelayedWorkQueue());

    }

ScheduledThreadPool 继承ThreadPoolExecutor super 就是ThreadPoolExecutor

 public ThreadPoolExecutor(int corePoolSize,

                              int maximumPoolSize,

                              long keepAliveTime,

                              TimeUnit unit,

                              BlockingQueue<Runnable> workQueue) {

        this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,

             Executors.defaultThreadFactory(), defaultHandler);

    }

SingleThreadExecutor

通过Executors.newSingleThreadExecutor(); 方法创建的，这类线程池内部只有一个核心线程，它确保所有的任务都在同一个线程中按顺序执行，SingleThreadExecutor的意义在于统一所有的外界任务到一个线程中，这使得在这些任务之间不需要处理线程同步的问题
源码:

 public static ExecutorService newSingleThreadExecutor() {

        return new FinalizableDelegatedExecutorService

            (new ThreadPoolExecutor(1, 1,

                                    0L, TimeUnit.MILLISECONDS,

                                    new LinkedBlockingQueue<Runnable>()));

    }

四大线程池的使用：

 private void runThreadPool() {

        /**

         * 要执行的操作

         */

        Runnable command = new Runnable() {

            @Override

            public void run() {

                Log.d(TAG, "runThreadPool");

            }

        };



        ExecutorService fixedThreadPool = Executors.newFixedThreadPool(4);

        fixedThreadPool.execute(command);



        ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

        cachedThreadPool.execute(command);



        ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(4);

        // 2000ms后执行command

        scheduledThreadPool.schedule(command, 2000, TimeUnit.MILLISECONDS);

        // 延迟10ms后，每隔1000ms执行一次command

        scheduledThreadPool.scheduleAtFixedRate(command, 10, 1000, TimeUnit.MILLISECONDS);



        ExecutorService singleThreadExecutor = Executors.newSingleThreadExecutor();

        singleThreadExecutor.execute(command);

    }

ExecutorService 常见方法

这里有几种不同的方式让你将任务委托给一个 ExecutorService：

execute(Runnable)
submit(Runnable)
submit(Callable)
invokeAny(…)
invokeAll(…)

execute(Runnable)

方法 execute(Runnable) 接收一个 java.lang.Runnable 对象作为参数，并且以异步的方式执行它。如下是一个使用 ExecutorService 执行 Runnable 的例子：

ExecutorService executorService = Executors.newSingleThreadExecutor();

executorService.execute(new Runnable() {
    public void run() {
        System.out.println("Asynchronous task");
    }
});

executorService.shutdown()

使用executorService.shutdown()这种方式没有办法获取执行 Runnable 之后的结果，如果你希望获取运行之后的返回值，就必须使用 接收 Callable 参数的 execute() 方法，后者将会在下文中提到。
submit(Runnable)

submit(Runnable)

方法 submit(Runnable) 同样接收一个Runnable 的实现作为参数，但是会返回壹個 Future 对象。这個 Future 对象可以用于判断 Runnable 是否结束执行。如下是壹個 ExecutorService 的 submit() 方法的例子：

Future future = executorService.submit(new Runnable() {
    public void run() {
        System.out.println("Asynchronous task");
    }
});
//如果任务结束执行则返回 null
System.out.println("future.get()=" + future.get());
submit(Callable)

submit(Callable)

方法 submit(Callable) 和方法 submit(Runnable) 比较类似，但是区别则在于它们接收不同的参数类型。Callable 的实例与 Runnable 的实例很类似，但是 Callable 的 call() 方法可以返回一个结果。方法 Runnable.run() 则不能返回结果。

Callable 的返回值可以从方法 submit(Callable) 返回的 Future 对象中获取。如下是一个 ExecutorService Callable 的样例：

Future future = executorService.submit(new Callable(){
    public Object call() throws Exception {
        System.out.println("Asynchronous Callable");
        return "Callable Result";
    }
});

System.out.println("future.get() = " + future.get());

上述样例代码会输出如下结果：
Asynchronous Callable
future.get() = Callable Result
inVokeAny()

invokeAny()

方法 invokeAny() 接收一个包含 Callable 对象的集合作为参数。调用该方法不会返回 Future 对象，而是返回集合中某一个 Callable 对象的结果，而且无法保证调用之后返回的结果是哪一个 Callable，只知道它是这些 Callable 中一个执行结束的 Callable 对象。
如果一个任务运行完毕或者抛出异常，方法会取消其它的 Callable 的执行。
以下是一个样例：

ExecutorService executorService = Executors.newSingleThreadExecutor();

Set<Callable<String>> callables = new HashSet<Callable<String>>();

callables.add(new Callable<String>() {
    public String call() throws Exception {
        return "Task 1";
    }
});
callables.add(new Callable<String>() {
    public String call() throws Exception {
        return "Task 2";
    }
});
callables.add(new Callable<String>() {
    public String call() throws Exception {
        return "Task 3";
    }
});

String result = executorService.invokeAny(callables);

System.out.println("result = " + result);

executorService.shutdown();

以上样例代码会打印出在给定的集合中的某壹個 Callable 的返回结果。我尝试运行了几次，结果都在改变。有时候返回结果是”Task 1”，有时候是”Task 2”，等等。

invokeAll()

方法 invokeAll() 会调用存在于参数集合中的所有 Callable 对象，并且返回一个包含 Future 对象的集合，你可以通过这个返回的集合来管理每個 Callable 的执行结果。
需要注意的是，任务有可能因为异常而导致运行结束，所以它可能并不是真的成功运行了。但是我们没有办法通过 Future 对象来了解到这個差异。
以下是一个代码样例：

ExecutorService executorService = Executors.newSingleThreadExecutor();

Set<Callable<String>> callables = new HashSet<Callable<String>>();

callables.add(new Callable<String>() {
    public String call() throws Exception {
        return "Task 1";
    }
});
callables.add(new Callable<String>() {
    public String call() throws Exception {
        return "Task 2";
    }
});
callables.add(new Callable<String>() {
    public String call() throws Exception {
        return "Task 3";
    }
});

List<Future<String>> futures = executorService.invokeAll(callables);

for(Future<String> future : futures){
    System.out.println("future.get = " + future.get());
}

executorService.shutdown();

关闭 ExecutorService

1. shutdown() 方法：此方法并不会马上关闭，而是不再接收新的任务，所有的线程结束执行当前任务，ExecutorService才会真的关闭
2. shutdownNow() 方法：立即关闭，这个方法会尝试马上关闭所有正在执行的任务，并且跳过所有已经提交但是还没有运行的任务，但是对于正在执行的任务是否能够成功关闭他是无法保证的