回顾Android中的线程池的使用方式。
ThreadPoolExecutor
线程池的创建主要与该类相关，通过设置不同的构造器参数来构造不同的线程池对象：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue)corePoolSize核心线程数，即便线程处于空闲状态也不会被回收，除非通过调用allowCoreThreadTimeOut(true)方法，并且keepAliveTime>0在情况下，核心线程才会回收；maximumPoolSize线程池中允许创建的最大线程数；keepAliveTime线程存活时间，如果当前的线程数量超过了核心线程数，并且存在空闲线程的情况下，在没有新任务到来时，空闲线程可以存活的最大时间；unit时间单位，用于keepAliveTime参数，可选值在TimeUnit枚举类中定义:NANOSECONDS 纳秒 MICROSECONDS 微秒 MILLISECONDS 毫秒 SECONDS 秒 MINUTES 分 HOURS 小时 DAYS 天workQueue阻塞队列，待执行的Runnable任务会被存放在该队列中；另外
ThreadPoolExecutor还有另外的三种构造方法:public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory) public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, RejectedExecutionHandler handler) } public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)threadFactory用于创建线程，如果不指定该参数将使用Executors.defaultThreadFactory()创建默认的ThreadFactoryhandler用于当ThreadPoolExecutor.execute()方法不能接受任务时的处理策略，比如没有更多的线程可用时，或者队列已满，或者ThreadPoolExecutor已经关闭，如果不指定该参数将使用默认的handler处理；明白了
ThreadPoolExecutor的创建方式，对于使用Executors创建线程池的方式会理解的比较清晰。
new Thread
在Android开发中，直接使用new Thread方式创建一个线程：
new Thread(new Runnable() {
@Override
public void run() {
Log.d("new Thread","new Thread 运行任务");
}
}).start();这种方式不推荐使用，尤其是需要执行的业务逻辑比较复杂的情况下，线程的创建和管理都比较难以控制，匿名内部类的形式也会隐式引用了this对象，有内存泄漏的风险。
Executors.newSingleThreadExecutor
从方法名就可以看出该方法不能叫做线程池，因为只new出了一个核心线程。
首先看看其无参数方法实现：
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}FinalizableDelegatedExecutorService其实是个代理包装类，这里不再分析，真正的创建者还是ThreadPoolExecutor。
从创建的参数可以知道：
- 核心线程数为1
- 最大线程数为1
- 存活时间为0，也就是说只保持一个核心线程
使用
LinkedBlockingQueue，容量为Integer.MAX_VALUE有参数方法只是可以自定义
threadFactory:public static ExecutorService newSingleThreadExecutor(ThreadFactory threadFactory) { return new FinalizableDelegatedExecutorService (new ThreadPoolExecutor(1, 1, 0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>(), threadFactory)); }上面两个方法都返回了一个
ExecutorService对象(实际上ThreadPoolExecutor间接实现了该接口)，它调用任务的方法：//单任务方法 void execute(Runnable command); public <T> Future<T> submit(Callable<T> task); public <T> Future<T> submit(Runnable task, T result); public Future<?> submit(Runnable task); //集合任务方法 invokeAll(Collection<? extends Callable<T>> tasks) invokeAll(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit) public <T> T invokeAny(Collection<? extends Callable<T>> tasks) public <T> T invokeAny(Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)不关心返回的情况下
execute方法最为常用:ExecutorService service = Executors.newSingleThreadExecutor(); for(int i=0;i<10;i++){ final int time = i; service.execute(new Runnable() { @Override public void run() { Log.d("执行任务"+(time +1),"工作线程"+Thread.currentThread().getName()); } }); }输入结果：
08-18 13:07:24.838 26071-26098 D/执行任务1: 工作线程pool-1-thread-1 08-18 13:07:24.839 26071-26098 D/执行任务2: 工作线程pool-1-thread-1 08-18 13:07:24.839 26071-26098 D/执行任务3: 工作线程pool-1-thread-1 08-18 13:07:24.839 26071-26098 D/执行任务4: 工作线程pool-1-thread-1 08-18 13:07:24.839 26071-26098 D/执行任务5: 工作线程pool-1-thread-1 08-18 13:07:24.839 26071-26098 D/执行任务6: 工作线程pool-1-thread-1 08-18 13:07:24.839 26071-26098 D/执行任务7: 工作线程pool-1-thread-1 08-18 13:07:24.839 26071-26098 D/执行任务8: 工作线程pool-1-thread-1 08-18 13:07:24.839 26071-26098 D/执行任务9: 工作线程pool-1-thread-1 08-18 13:07:24.839 26071-26098 D/执行任务10: 工作线程pool-1-thread-1可以看到工作线程始终只有一个。
submit方法其实最终将任务封装为了FutureTask对象，和Runnable任务的主要区别是可以获取返回结果，这里不再介绍。
Executors.newFixedThreadPool
该方法可以创建固定核心线程数的线程池：
public static ExecutorService newFixedThreadPool(int nThreads) {
return new ThreadPoolExecutor(nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>());
}- 核心线程数为nThreads
- 最大线程数为nThreads
- 存活时间为0，也就是说只保持一个核心线程
- 同样使用
LinkedBlockingQueue，容量为Integer.MAX_VALUE
使用举例：
ExecutorService service = Executors.newFixedThreadPool(3);
for(int i=0;i<10;i++){
final int time = i;
service.execute(new Runnable() {
@Override
public void run() {
Log.d("执行任务"+(time +1),"工作线程"+Thread.currentThread().getName());
}
});
}输出结果：
08-18 13:06:04.167 25855-25882 D/执行任务2: 工作线程pool-1-thread-2
08-18 13:06:04.167 25855-25883 D/执行任务3: 工作线程pool-1-thread-3
08-18 13:06:04.167 25855-25881 D/执行任务1: 工作线程pool-1-thread-1
08-18 13:06:04.167 25855-25883 D/执行任务4: 工作线程pool-1-thread-3
08-18 13:06:04.167 25855-25882 D/执行任务5: 工作线程pool-1-thread-2
08-18 13:06:04.167 25855-25881 D/执行任务6: 工作线程pool-1-thread-1
08-18 13:06:04.167 25855-25883 D/执行任务7: 工作线程pool-1-thread-3
08-18 13:06:04.167 25855-25882 D/执行任务8: 工作线程pool-1-thread-2
08-18 13:06:04.167 25855-25883 D/执行任务9: 工作线程pool-1-thread-3
08-18 13:06:04.167 25855-25882 D/执行任务10: 工作线程pool-1-thread-2可以看出只有三个核心工作线程。
也有newFixedThreadPool(int nThreads, ThreadFactory threadFactory)使用threadFactory的方法。
相比较newSingleThreadExecutor，主要在核心线程数的数量可以自定义。
Executors.newCachedThreadPool
该方法只能创建非核心线程，并且不能指定线程数量:
public static ExecutorService newCachedThreadPool() {
return new ThreadPoolExecutor(0, Integer.MAX_VALUE,
60L, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>());
}- 核心线程数为
0 - 最大线程数为
Integer.MAX_VALUE - 存活时间为
60秒 - 使用
SynchronousQueue，该队列不存在缓冲，该队列不再介绍。
使用举例：
ExecutorService service = Executors.newCachedThreadPool();
for(int i=0;i<10;i++){
final int time = i;
service.execute(new Runnable() {
@Override
public void run() {
Log.d("执行任务"+(time +1),"工作线程"+Thread.currentThread().getName());
}
});
}输出结果：
08-18 13:10:06.677 26439-26469 D/执行任务2: 工作线程pool-1-thread-2
08-18 13:10:06.677 26439-26468 D/执行任务1: 工作线程pool-1-thread-1
08-18 13:10:06.678 26439-26468 D/执行任务5: 工作线程pool-1-thread-1
08-18 13:10:06.678 26439-26470 D/执行任务3: 工作线程pool-1-thread-3
08-18 13:10:06.678 26439-26469 D/执行任务6: 工作线程pool-1-thread-2
08-18 13:10:06.679 26439-26469 D/执行任务8: 工作线程pool-1-thread-2
08-18 13:10:06.679 26439-26471 D/执行任务4: 工作线程pool-1-thread-4
08-18 13:10:06.679 26439-26470 D/执行任务9: 工作线程pool-1-thread-3
08-18 13:10:06.680 26439-26468 D/执行任务10: 工作线程pool-1-thread-1
08-18 13:10:06.680 26439-26472 D/执行任务7: 工作线程pool-1-thread-5可以看出有5个工作线程，但是并不是核心线程，随着任务数量的变化，线程数量也可能随之变化。
同样有使用·threadFactory的方法newCachedThreadPool(ThreadFactory threadFactory)。
Executors.newScheduledThreadPool
创建一个具有定时执行任务和延时任务的线程池，需要指定核心线程数量：
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) {
return new ScheduledThreadPoolExecutor(corePoolSize);
}
public ScheduledThreadPoolExecutor(int corePoolSize) {
//super方法其实就是ThreadPoolExecutor的构造
super(corePoolSize, Integer.MAX_VALUE,
DEFAULT_KEEPALIVE_MILLIS, MILLISECONDS,
new DelayedWorkQueue());
}- 核心线程数为
corePoolSize参数 - 最大线程数为
Integer.MAX_VALUE - 存活时间为
10毫秒 使用
DelayedWorkQueue，延时队列，任务会按照延时间排序，这里不再介绍。在使用方法上除了
execute和submit方法，最主要的区别能够执行延时和定时任务，
首先看下延时任务的方法：
public ScheduledFuture<?> schedule(Runnable command,
long delay, TimeUnit unit);commandRunnable任务delay任务执行延迟unit时间单位使用举例:
ScheduledExecutorService service = Executors.newScheduledThreadPool(3); Log.d("准备",System.currentTimeMillis()+""); service.schedule(new Runnable() { @Override public void run() { Log.d("执行",System.currentTimeMillis()+""); } },1,TimeUnit.SECONDS);输出结果：
08-18 13:18:02.099 27086-27086 D/准备: 1534569482099
08-18 13:18:03.100 27086-27103 D/执行: 1534569483100基本延时在1秒才执行任务。
执行固定延时任务的方法：
public ScheduledFuture<?> scheduleWithFixedDelay(Runnable command,
long initialDelay,
long delay,
TimeUnit unit);commandRunnable任务initialDelay任务首次执行延迟delay任务间执行的间隔unit时间单位该方法在执行任务时候，只有在执行完前一个任务后，才会在指定的
delay延迟后执行下一个任务。
使用举例：ScheduledExecutorService service = Executors.newScheduledThreadPool(3); Log.d("准备", System.currentTimeMillis() + ""); service.scheduleWithFixedDelay(new Runnable() { @Override public void run() { try { Log.d("执行中", "当前毫秒："+System.currentTimeMillis() + "--工作线程"+ Thread.currentThread().getName()); Thread.currentThread().sleep(2000); Log.d("执行完毕", "当前毫秒："+System.currentTimeMillis() + "--工作线程"+ Thread.currentThread().getName()); } catch (InterruptedException e) { e.printStackTrace(); } } },1,1,TimeUnit.SECONDS);输出结果：
08-18 13:52:11.403 29909-29909 D/准备: 1534571531403 08-18 13:52:12.405 29909-29939 D/执行中: 当前毫秒：1534571532404--工作线程pool-1-thread-1 08-18 13:52:14.406 29909-29939 D/执行完毕: 当前毫秒：1534571534405--工作线程pool-1-thread-1 08-18 13:52:15.408 29909-29939 D/执行中: 当前毫秒：1534571535407--工作线程pool-1-thread-1 08-18 13:52:17.409 29909-29939 D/执行完毕: 当前毫秒：1534571537408--工作线程pool-1-thread-1 08-18 13:52:18.410 29909-29939 D/执行中: 当前毫秒：1534571538410--工作线程pool-1-thread-1 08-18 13:52:20.411 29909-29939 D/执行完毕: 当前毫秒：1534571540411--工作线程pool-1-thread-1 08-18 13:52:21.412 29909-29939 D/执行中: 当前毫秒：1534571541412--工作线程pool-1-thread-1 08-18 13:52:23.413 29909-29939 D/执行完毕: 当前毫秒：1534571543413--工作线程pool-1-thread-1 08-18 13:52:24.414 29909-29939 D/执行中: 当前毫秒：1534571544414--工作线程pool-1-thread-1 08-18 13:52:26.415 29909-29939 D/执行完毕: 当前毫秒：1534571546415--工作线程pool-1-thread-1可以看到执行完
2秒的耗时任务后，再间隔1秒继续执行下一个任务，如此循环。
执行定时任务的方法：public ScheduledFuture<?> scheduleAtFixedRate(Runnable command, long initialDelay, long period, TimeUnit unit);commandRunnable任务initialDelay任务首次执行延迟delay任务执行定时间隔unit时间单位
该方法能够进行周期性的定时任务，使用举例：
final ScheduledExecutorService service = Executors.newScheduledThreadPool(3);
Log.d("准备", System.currentTimeMillis() + "");
service.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
try {
Log.d("执行中", "当前毫秒："+System.currentTimeMillis() + "--工作线程"+ Thread.currentThread().getName());
Thread.currentThread().sleep(500);
Log.d("执行完毕", "当前毫秒："+System.currentTimeMillis() + "--工作线程"+ Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},1,1,TimeUnit.SECONDS);输出结果：
08-18 13:47:56.782 29404-29404 D/准备: 1534571276782
08-18 13:47:57.782 29404-29434 D/执行中: 当前毫秒：1534571277782--工作线程pool-1-thread-1
08-18 13:47:58.283 29404-29434 D/执行完毕: 当前毫秒：1534571278283--工作线程pool-1-thread-1
08-18 13:47:58.782 29404-29434 D/执行中: 当前毫秒：1534571278782--工作线程pool-1-thread-1
08-18 13:47:59.282 29404-29434 D/执行完毕: 当前毫秒：1534571279282--工作线程pool-1-thread-1
08-18 13:47:59.782 29404-29446 D/执行中: 当前毫秒：1534571279782--工作线程pool-1-thread-2
08-18 13:48:00.282 29404-29446 D/执行完毕: 当前毫秒：1534571280282--工作线程pool-1-thread-2
08-18 13:48:00.782 29404-29446 D/执行中: 当前毫秒：1534571280782--工作线程pool-1-thread-2
08-18 13:48:01.283 29404-29446 D/执行完毕: 当前毫秒：1534571281282--工作线程pool-1-thread-2
08-18 13:48:01.783 29404-29446 D/执行中: 当前毫秒：1534571281783--工作线程pool-1-thread-2
08-18 13:48:02.284 29404-29446 D/执行完毕: 当前毫秒：1534571282283--工作线程pool-1-thread-2需要注意的是如果任务执行的时间超过delay的定时时间，那么定时周期将失效。
举例说明，任务执行时间增加到2秒:
final ScheduledExecutorService service = Executors.newScheduledThreadPool(3);
Log.d("准备", System.currentTimeMillis() + "");
service.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
try {
Log.d("执行中", "当前毫秒："+System.currentTimeMillis() + "--工作线程"+ Thread.currentThread().getName());
Thread.currentThread().sleep(2000);//超过了执行周期1秒
Log.d("执行完毕", "当前毫秒："+System.currentTimeMillis() + "--工作线程"+ Thread.currentThread().getName());
} catch (InterruptedException e) {
e.printStackTrace();
}
}
},1,1,TimeUnit.SECONDS);输出结果：
08-18 13:54:13.247 30253-30253 D/准备: 1534571653247
08-18 13:54:14.247 30253-30284 D/执行中: 当前毫秒：1534571654247--工作线程pool-1-thread-1
08-18 13:54:16.248 30253-30284 D/执行完毕: 当前毫秒：1534571656248--工作线程pool-1-thread-1
08-18 13:54:16.250 30253-30284 D/执行中: 当前毫秒：1534571656250--工作线程pool-1-thread-1
08-18 13:54:18.251 30253-30284 D/执行完毕: 当前毫秒：1534571658251--工作线程pool-1-thread-1
08-18 13:54:18.254 30253-30284 D/执行中: 当前毫秒：1534571658254--工作线程pool-1-thread-1
08-18 13:54:20.255 30253-30284 D/执行完毕: 当前毫秒：1534571660255--工作线程pool-1-thread-1
08-18 13:54:20.256 30253-30284 D/执行中: 当前毫秒：1534571660256--工作线程pool-1-thread-1
08-18 13:54:22.257 30253-30284 D/执行完毕: 当前毫秒：1534571662257--工作线程pool-1-thread-1
08-18 13:54:22.258 30253-30284 D/执行中: 当前毫秒：1534571662258--工作线程pool-1-thread-1可以看到在执行完毕后，并没有间隔1秒执行，而是立即执行，因此周期失效。
同样也存在newScheduledThreadPool( 使用
int corePoolSize, ThreadFactory threadFactory)threadFactory的方法。
Executors.newSingleThreadScheduledExecutor
该方法和newScheduledThreadPool主要区别就是不能指定核心线程数量，只有一个核心线程：
public static ScheduledExecutorService newSingleThreadScheduledExecutor() {
return new DelegatedScheduledExecutorService
(new ScheduledThreadPoolExecutor(1));
}Executors.newWorkStealingPool(API 24)
该方法可以创建ForkJoinPool线程池，ForkJoinPool在JDK1.7引入，主要能够利用多核cpu将一个任务进行拆解成多个子任务，把多个子任务放到多个处理器核心上并行执行，所有的任务执行完毕后，再将结果合并：
public static ExecutorService newWorkStealingPool() {
return new ForkJoinPool
(Runtime.getRuntime().availableProcessors(),
ForkJoinPool.defaultForkJoinWorkerThreadFactory,
null, true);
}shutDown和showDownNow
shutDown方法被调用后，已经提交到线程池的任务会被执行完毕，但不能够再添加新的任务。
举例：
final ExecutorService service = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int time = i;
service.execute(new Runnable() {
@Override
public void run() {
Log.d("执行任务" + (time + 1), "工作线程" + Thread.currentThread().getName());
try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
service.shutdown();
Log.d("任务结束","shutdown");
//关闭后再尝试执行任务
service.execute(new Runnable() {
@Override
public void run() {
}
});输出结果：
08-18 14:20:47.509 32522-32551 D/执行任务1: 工作线程pool-1-thread-1
08-18 14:20:47.509 32522-32522 D/任务结束: shutdown
08-18 14:20:47.510 32522-32553 D/执行任务3: 工作线程pool-1-thread-3
08-18 14:20:47.510 32522-32552 D/执行任务2: 工作线程pool-1-thread-2
08-18 14:20:47.510 32522-32522 D/AndroidRuntime: Shutting down VM
--------- beginning of crash
08-18 14:20:47.511 32522-32522 E/AndroidRuntime: FATAL EXCEPTION: main
Process: com.franky.test, PID: 32522
java.lang.RuntimeException: Unable to start activity ComponentInfo{com.franky.test/com.franky.test.ThreadActivity}: java.util.concurrent.RejectedExecutionException: Task com.franky.test.ThreadActivity$2@e0aa6ca rejected from java.util.concurrent.ThreadPoolExecutor@396c03b[Shutting down, pool size = 3, active threads = 3, queued tasks = 7, completed tasks = 0]
at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2666)
at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:2727)
at android.app.ActivityThread.-wrap12(ActivityThread.java)
at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1478)
at android.os.Handler.dispatchMessage(Handler.java:102)
at android.os.Looper.loop(Looper.java:154)
at android.app.ActivityThread.main(ActivityThread.java:6121)
at java.lang.reflect.Method.invoke(Native Method)
at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:889)
at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:779)
Caused by: java.util.concurrent.RejectedExecutionException: Task com.franky.test.ThreadActivity$2@e0aa6ca rejected from java.util.concurrent.ThreadPoolExecutor@396c03b[Shutting down, pool size = 3, active threads = 3, queued tasks = 7, completed tasks = 0]
at java.util.concurrent.ThreadPoolExecutor$AbortPolicy.rejectedExecution(ThreadPoolExecutor.java:2049)
at java.util.concurrent.ThreadPoolExecutor.reject(ThreadPoolExecutor.java:814)
at java.util.concurrent.ThreadPoolExecutor.execute(ThreadPoolExecutor.java:1360)
at com.franky.test.ThreadActivity.shutdown(ThreadActivity.java:54)
at com.franky.test.ThreadActivity.onCreate(ThreadActivity.java:33)
at android.app.Activity.performCreate(Activity.java:6682)
at android.app.Instrumentation.callActivityOnCreate(Instrumentation.java:1118)
at android.app.ActivityThread.performLaunchActivity(ActivityThread.java:2619)
at android.app.ActivityThread.handleLaunchActivity(ActivityThread.java:2727)
at android.app.ActivityThread.-wrap12(ActivityThread.java)
at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1478)
at android.os.Handler.dispatchMessage(Handler.java:102)
at android.os.Looper.loop(Looper.java:154)
at android.app.ActivityThread.main(ActivityThread.java:6121)
at java.lang.reflect.Method.invoke(Native Method)
at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:889)
at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:779)
08-18 14:20:48.510 32522-32553 D/执行任务4: 工作线程pool-1-thread-3
08-18 14:20:48.512 32522-32551 D/执行任务5: 工作线程pool-1-thread-1
08-18 14:20:48.560 32522-32552 D/执行任务6: 工作线程pool-1-thread-2
08-18 14:20:49.551 32522-32551 D/执行任务7: 工作线程pool-1-thread-1
08-18 14:20:49.551 32522-32553 D/执行任务8: 工作线程pool-1-thread-3
08-18 14:20:49.601 32522-32552 D/执行任务9: 工作线程pool-1-thread-2
08-18 14:20:50.591 32522-32551 D/执行任务10: 工作线程pool-1-thread-1可以看到调用shutdown方法后，未执行的任务会继续执行完毕，但尝试继续添加任务后会抛出异常。
showDownNow方法调用后正在执行的任务会直接中断，并返回未执行的任务集合。
举例:
final ExecutorService service = Executors.newFixedThreadPool(3);
for (int i = 0; i < 10; i++) {
final int time = i;
service.execute(new Runnable() {
@Override
public void run() {
Log.d("执行任务" + (time + 1), "工作线程" + Thread.currentThread().getName());
try {
Thread.currentThread().sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
}
List<Runnable> runnables = service.shutdownNow();
Log.d("任务结束","shutdown");
for (Runnable runnable : runnables) {
runnable.run();
}输出结果:
08-18 14:13:28.891 31824-31824 D/任务结束: shutdown
08-18 14:13:28.891 31824-31841 D/执行任务1: 工作线程pool-1-thread-1
08-18 14:13:28.891 31824-31824 D/执行任务4: 工作线程main
08-18 14:13:28.892 31824-31843 D/执行任务3: 工作线程pool-1-thread-3
08-18 14:13:28.892 31824-31842 D/执行任务2: 工作线程pool-1-thread-2
08-18 14:13:28.892 31824-31842 W/System.err: java.lang.InterruptedException
at java.lang.Thread.sleep(Native Method)
at java.lang.Thread.sleep(Thread.java:371)
at java.lang.Thread.sleep(Thread.java:313)
at com.franky.test.ThreadActivity$1.run(ThreadActivity.java:45)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1133)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:607)
at java.lang.Thread.run(Thread.java:761)
08-18 14:13:28.893 31824-31841 W/System.err: java.lang.InterruptedException
at java.lang.Thread.sleep(Native Method)
at java.lang.Thread.sleep(Thread.java:371)
at java.lang.Thread.sleep(Thread.java:313)
at com.franky.test.ThreadActivity$1.run(ThreadActivity.java:45)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1133)
at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:607)
at java.lang.Thread.run(Thread.java:761)
08-18 14:13:28.894 31824-31843 W/System.err: java.lang.InterruptedException
at java.lang.Thread.sleep(Native Method)
at java.lang.Thread.sleep(Thread.java:371)
at java.lang.Thread.sleep(Thread.java:313)
at com.franky.test.ThreadActivity$1.run(ThreadActivity.java:45)
at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1133)
08-18 14:13:28.896 31824-31843 W/System.err: at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:607)
at java.lang.Thread.run(Thread.java:761)
08-18 14:13:29.891 31824-31824 D/执行任务5: 工作线程main
08-18 14:13:30.892 31824-31824 D/执行任务6: 工作线程main
08-18 14:13:31.893 31824-31824 D/执行任务7: 工作线程main
08-18 14:13:32.894 31824-31824 D/执行任务8: 工作线程main
08-18 14:13:33.895 31824-31824 D/执行任务9: 工作线程main
08-18 14:13:34.895 31824-31824 D/执行任务10: 工作线程main可以看到在工作线程执行的任务只进行了3个，就被中断了，而且返回了未执行的任务集合。
其他
在选用线程池的时候需要根据不同的场景选择合适的线程池，避免可能发生的如单线程池线程阻塞或者缓存线程池的内存溢出等情况，也可以根据情况自己构造ThreadPoolExecutor类。
751
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
