@author：小马快跑
@email：[email protected]
@github：https://github.com/crazyqiang
学习线程池必备知识：
在开始介绍线程池之前，先来介绍下Callable和Future的概念，众所周知，Android中实现多线程的方式有两种，实现Runnable接口或者继承一个Thread，但是这两种方式都有一个缺点：在任务执行完成之后没有返回结果，所以在Java 1.5之后，出现了Callable和Future，通过他们构建的线程，可以在线程执行完成之后得到返回结果。
先来对比Runnable 和Callable：
Runnable ：
public interface Runnable {
public abstract void run();
}
Callable：
public interface Callable {
V call() throws Exception;
}
Runnable 接口中的run()方法的返回值是void，所以Runnable无返回值；而Callable接口中的call()方法的返回值是V，也可以抛出异常，所以Callable是可以有返回值的。接着来看下Future：
Future：
public interface Future {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
Future
| Future | 备注 |
|---|---|
| cancel(boolean) | 尝试取消异步任务的执行。如果任务已经执行完成、已经被取消、因为某种原因不能被取消，则返回false；如果任务正在执行，并且mayInterruptIfRunning为true，那么会调用interrupt()尝试打断任务。该方法返回结果后，isDone()总会返回true |
| isCancelled() | 如果在任务完成前被取消，返回true |
| isDone() | 如果任务完成则返回true。任务完成包括正常结束、任务被取消、任务发生异常，都返回true |
| get() | 获取异步任务执行结果，如果没有返回，则阻塞等待 |
| get(long timeout, TimeUnit unit) | 在给定的时间内等待获取异步任务结果，如果超时还未获取到结果，则会抛出TimeoutException |
Future
以FutureTask为例，具体分析下FutureTask：
public class FutureTask implements RunnableFuture {
................其他.....................
}
咦？FutureTask并没有实现Future接口，而是实现了一个叫RunnableFuture的接口，这货从哪里蹦出来的？我们点进去看一下：
public interface RunnableFuture extends Runnable, Future {
/**
* Sets this Future to the result of its computation
* unless it has been cancelled.
*/
void run();
}
吆西！原来这货不仅继承了Future接口，还继承了Runnable接口(PS：接口可以多继承)，那么我们的FutureTask也就实现了Runnable和Future接口
| FutureTask | 备注 |
|---|---|
| boolean isCancelled() | 同Future |
| boolean isDone() | 同Future |
| boolean cancel(boolean mayInterruptIfRunning) | 同Future |
| V get() | 同Future |
| V get(long timeout, TimeUnit unit) | 同Future |
| void run() | 如果这个任务没有被取消，将直接在当前线程内执行任务 |
FutureTask有两个构造方法：
public FutureTask(Callable callable)
public FutureTask(Runnable runnable, V result)
我们看到FutureTask初始化时不仅可以传入Callable，还可以传入一个Runnable和一个"返回结果result"，这里为什么返回结果要加引号呢，来看下源码就知道了：
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}
上面FutureTask()的初始化构造参数中调用了Executors.callable()：
public static Callable callable(Runnable task, T result) {
if (task == null)
throw new NullPointerException();
return new RunnableAdapter(task, result);
}
private static final class RunnableAdapter implements Callable {
private final Runnable task;
private final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task;
this.result = result;
}
public T call() {
task.run();
//把传入的值直接返回
return result;
}
}
通过源码我们看到，在最后的call()方法中，直接把传入的值返回了，所以FutureTask(Runnable runnable, V result)得到的只是预设的结果，Runnable并不会得到执行的结果。如果不需要预设的返回结果，可以像下面这样初始化：
Future f = new FutureTask(runnable, null)
FutureTask的使用：
//初始化一个线程池
ExecutorService executor = = Executors.newSingleThreadExecutor();
//new 一个Callable并传入FutureTask
FutureTask future =new FutureTask<>(new Callable() {
public String call() {
//do something
return result;
}});
executor.execute(future);
//在异步任务执行期间可以做一些其他的事情
displayOtherThings();
//通过future.get()得到异步任务执行结果
String result=future.get();
ExecutorService ：
ExecutorService继承自Executor接口，并提供了管理线程以及创建可以追踪一个或多个异步任务的进展的Future的方法。
public interface ExecutorService extends Executor {
//无法提交新任务，但是已经提交的任务将继续执行，当执行完成后关闭线程池
void shutdown();
//尝试停止所有正在执行的任务，暂停等待任务的处理，并返回等待执行的任务列表。
List shutdownNow();
//如果线程池已经关闭则返回true
boolean isShutdown();
//如果所有任务都在线程池关闭后完成，则返回true。注意，除非首先调用 shutdown 或 shutdownNow，否则 isTerminated 永不为 true。
boolean isTerminated();
//阻塞等待，直到所有任务在关闭请求后完成执行，或者超时发生，或者当前线程被中断
// 如果此执行程序终止，则返回 true；如果终止前超时了，则返回 false
boolean awaitTermination(long timeout, TimeUnit unit)
throws InterruptedException;
Future submit(Callable task);
Future submit(Runnable task, T result);
//提交一个 Runnable 任务用于执行，并返回一个表示该任务的 Future。该 Future 的 get 方法在成功 完成时将会返回 null
Future submit(Runnable task);
List> invokeAll(Collection> tasks)
throws InterruptedException;
//执行给定的任务，当所有任务完成或超时期满时（无论哪个首先发生），返回保持任务状态和结果的 Future 列表。
//返回列表的所有元素的 Future.isDone() 为 true。一旦返回后，即取消尚未完成的任务。
//注意，可以正常地或通过抛出异常来终止已完成 任务。如果此操作正在进行时修改了给定的
// collection，则此方法的结果是不确定的。
List> invokeAll(Collection> tasks,
long timeout, TimeUnit unit)
throws InterruptedException;
T invokeAny(Collection> tasks)
throws InterruptedException, ExecutionException;
//执行给定的任务，如果在给定的超时期满前某个任务已成功完成（也就是未抛出异常），则返回其结果。
//一旦正常或异常返回后，则取消尚未完成的任务。如果此操作正在进行时修改了给定的 collection，
//则此方法的结果是不确定的。
T invokeAny(Collection> tasks,
long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
线程池的使用：
使用线程池的好处：
1、当执行大量异步任务时，线程池能提供更好的性能体验，因为线程池能减少每个任务的调用开销，重用存在的线程，减少对象创建、消亡的开销
2、还可以提供绑定和管理资源 (包括执行任务时使用的线程) 的方法。有效控制最大并发线程数，提高系统资源的使用率，同时避免过多资源竞争，避免堵塞
3、 提供定时执行、定期执行、单线程、并发数控制等功能。
Android中提供了四种线程池，四种线程池内部实现都是直接或者间接用的ThreadPoolExecutor。
1、Executors.newCachedThreadPool()：只有Integer.MAX_VALUE个非核心线程，当有任务来时，如果线程池中的线程都处于活动状态，那么会新建线程来执行，否则就会利用空闲线程去执行，空闲线程都会有一个超时机制，超过60秒的空闲线程会被回收。任务队列为空集合，所以所有任务都会被立即执行，CachedThreadPool适合执行大量的耗时较少的操作。
效果图：
因为非核心线程数有无限个，所以不管有多少任务都可以并行执行，可以看到上述5个任务一起执行，核心代码：
//初始化线程池
ExecutorService threadPool= Executors.newCachedThreadPool();
//初始化Callable
Callable callable = new Callable() {
int num = 0;
@Override
public Integer call() throws Exception {
while (num < 100) {
num++;
sendMsg(num, what);
Thread.sleep(50);
}
return 100;
}
};
//执行线程任务
threadPool.submit(callable);
2、Executors.newFixedThreadPool(int nThreads)：只有核心线程并且不会被回收，任务队列没有大小限制。
效果图：
因为核心线程数参数我们传入的是4，可所以看到先执行其中的4个任务，等待有任务执行完成后接着去执行第5个任务，核心代码：
//初始化线程池
ExecutorService threadPool= Executors.newFixedThreadPool(4);
//初始化Callable
Callable callable = new Callable() {
int num = 0;
@Override
public Integer call() throws Exception {
while (num < 100) {
num++;
sendMsg(num, what);
Thread.sleep(50);
}
return 100;
}
};
//执行线程任务
threadPool.submit(callable);
3、Executors.newSingleThreadExecutor()：内部只有一个核心线程，所有任务按顺序执行 统一所有任务到一个线程中，使得这些任务不用处理线程同步问题。
效果图：
可以看到每次只能执行一个任务，也就是所有任务都是串行执行的，核心代码：
//初始化线程池
ExecutorService threadPool= Executors.newSingleThreadExecutor();
//初始化Callable
Callable callable = new Callable() {
int num = 0;
@Override
public Integer call() throws Exception {
while (num < 100) {
num++;
sendMsg(num, what);
Thread.sleep(50);
}
return 100;
}
};
//执行线程任务
threadPool.submit(callable);
4、Executors.newScheduledThreadPool(int corePoolSize)： 核心线程是固定的，非核心线程是不固定的，非核心线程闲置时会被立即回收，主要用于执行定时任务和具有周期性的重复任务。
效果图：
ScheduledExecutorService传入的核心线程数是4，并且是在延迟2秒之后执行的，核心代码：
//初始化线程池，核心线程数为4
ScheduledExecutorService scheduledPool = Executors.newScheduledThreadPool(4);
//初始化Callable
Callable callable = new Callable() {
int num = 0;
@Override
public Integer call() throws Exception {
while (num < 100) {
num++;
sendMsg(num, what);
Thread.sleep(50);
}
return 100;
}
};
//延迟2秒后执行
scheduledPool.schedule(callable, 2, TimeUnit.SECONDS);
除上述延迟执行的方法外，ScheduledExecutorService中还有下列方法：
public interface ScheduledExecutorService extends ExecutorService {
//延迟delay(TimeUnit 为单位)之后执行Runnable
public ScheduledFuture schedule(Runnable command,
long delay, TimeUnit unit);
//延迟delay(TimeUnit 为单位)之后执行Callable
public ScheduledFuture schedule(Callable callable,
long delay, TimeUnit unit);
//延迟initialDelay之后每period时间执行一次Callable，循环执行
public ScheduledFuture scheduleAtFixedRate(Runnable command,
long initialDelay,
long period,
TimeUnit unit);
//第一次延迟initialDelay之后执行，之后在每次完成后延迟delay时间执行下一次操作
public ScheduledFuture scheduleWithFixedDelay(Runnable command,
long initialDelay,
long delay,
TimeUnit unit);
}
本文例子中完整代码已上传github：Android线程池的使用