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 执行任务时大致遵循如下规则：

如果线程池中的线程数量未达到核心线程的数量，那么会直接启动一个核心线程来执行任务

如果线程池中的线程数量已经达到或者超过核心线程的数量，那么任务会被插入到任务队列中排队等待执行

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

shutdown() 方法：此方法并不会马上关闭，而是不再接收新的任务，所有的线程结束执行当前任务，ExecutorService才会真的关闭

shutdownNow() 方法：立即关闭，这个方法会尝试马上关闭所有正在执行的任务，并且跳过所有已经提交但是还没有运行的任务，但是对于正在执行的任务是否能够成功关闭他是无法保证的