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() 方法:立即关闭,这个方法会尝试马上关闭所有正在执行的任务,并且跳过所有已经提交但是还没有运行的任务,但是对于正在执行的任务是否能够成功关闭他是无法保证的