一直想写关于AsyncTask的实现原理，AsyncTask的实现是用到了线程池和消息机制的，关于Android中的消息机制我已经在博客里写过了，有兴趣的同学可以去阅读。
那这篇博客就一起来学习Android中的线程池。关于Android的线程池有2篇。
在讲解Android中的线程池前，先介绍两个和线程池相关的类，在AsyncTask的实现中也会接触到。
Callable与FutureTask
Callable是一个泛型接口，接收一个泛型参数V，内部只有一个返回值为V的call方法
public interface Callable<V> {
V call() throws Exception;
}
我们对Runnable比较熟悉，Callable和Runnable很相似，区别是Callable的call方法有返回值，而Runnable的run方法没有返回值。
Runable是包装在Thread 内部，而Callable包装在FutureTask内部。
那就来看看FutureTask吧。从FutureTask的继承结构说起：
public class FutureTask<V> implements RunnableFuture<V> {
//代码省略
}
FutureTask实现了RunnableFuture接口的，可RunnableFuture怎么那么像Runnable和Future的合体？Future又是什么？
那么看看RunnableFuture接口
public interface RunnableFuture<V> extends Runnable, Future<V> {
/**
* Sets this Future to the result of its computation
* unless it has been cancelled.
*/
void run();
}
果然RunnableFuture是继承自Runnable和Future的。
那么Future是什么呢？
官方文档对其的描述是这样的：
A Future represents the result of an asynchronous computation. 而我查阅相关书籍得到了更好的描述是： Future为线程池制定了一个可管理的任务标准，它提供了对Runnable，Callable任务的执行结果进行取消，查询是否完成，获取结果，设置结果的操作。
public interface Future<V> {
boolean cancel(boolean mayInterruptIfRunning);
boolean isCancelled();
boolean isDone();
V get() throws InterruptedException, ExecutionException;
V get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException;
}
而FaskTask作为Runnable和Future的实现类，那也就有了他们两者的能力。简单理解就是有了可以获取任务执行之后的结果等等很强大的能力。 那既然FutureTask那么强大，就继续挖掘他内部的信息吧。
从FutureTask的构造方法开始：
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW; // ensure visibility of callable
}
这个构造方法接收一个Callable对象，这样就在内部完成了对Callable的包装。
接着看第二个构造方法：
public FutureTask(Runnable runnable, V result) {
this.callable = Executors.callable(runnable, result);
this.state = NEW; // ensure visibility of callable
}
Executors调用callable方法将传入的Runnable转换为Callable并赋值给FutureTask的callable字段。
在Android中创建线程池是使用工厂方法的模式的，而这个工厂就是Executors。这个先放放，会讲到的。
先来看下Executors的callable方法的内部逻辑：
public static <T> Callable<T> callable(Runnable task, T result) {
if (task == null)
throw new NullPointerException();
return new RunnableAdapter<T>(task, result);
}
如果传入的Runnable为null，则会抛出空指针异常。否则将Runnable传入RunnableAdapter的构造方法。
这个RunnableAdapter是Executors的内部类。是实现了Callable接口的。那么继续跟进RunnableAdapter看看
static final class RunnableAdapter<T> implements Callable<T> {
final Runnable task;
final T result;
RunnableAdapter(Runnable task, T result) {
this.task = task;
this.result = result;
}
public T call() {
task.run();
return result;
}
}
内部的逻辑实现是用到了适配器模式，从构造方法中传入Runnable对象，然后Callable调用call方法时，实际上内部执行的是Runnable的run方法。但是在外部看来，我就是在调用Callable的call方法，call方法内部逻辑我作为调用者是不关心的。
关于适配器模式我也写过一篇博客，有兴趣的同学也可以去阅读一下。
好了，我们可以总结一下，在创建FutureTask的时候，如果注入的是Runnable，则会被Executors的callable方法转换成Callable。
如果注入的是Callable，FutureTask还是会执行Callable的任务。
也就是说无论传入Callable或Runnable，FutureTask最终执行的都是Callable的任务。
FutureTask的创建好像挺复杂的哦。其实不复杂，我觉的只是设计的巧妙而已，就是做初始化的工作嘛。
那么刚才说到FutureTask是Runnable和Future的合体，那么FutureTask一定实现了Runnable的run方法的吧，我们可以看看FutureTask的run方法内部实现：
public void run() {
if (state != NEW ||
!U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
如果FutureTask的创建是正常的话，那么
if (c != null && state == NEW)这个判断是能通过的。从这个if语句的逻辑可以知道。FutureTask调用run方法就一定会调用Callable的call方法，并将执行结果赋值给result，result也是一个泛型，从创建FutureTask那一刻已经定了。
最后会调用set方法讲result设置进去。因此我们可以通过get方法来获取run方法执行的结果， 因为run方法内部包装了call方法，更准确说是获取call方法的执行结果。这就是FutureTask设计的强大之处。
好了。讲了很多，还不知道FutureTask怎么使用呢。其实Callable和FutureTask是用于线程池的。
线程池
上面提到，线程池是使用工厂方法的模式来创建的。我们可以这样创建一个简单的线程池。
ExecutorService mExecutor = Executors.newSingleThreadExecutor();创建一个FutureTask对象
FutureTask<Integer> futureTask = new FutureTask<Integer>(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
//具体逻辑
return null;
}
});将FutureTask提交就行了。
mExecutor.submit(futureTask);我们可以通过
futureTask.get();来获取执行的结果
而至于调用submit方法提交FutureTask之后又是怎么样的呢？我们之前分析过，Callable封装在FutureTask中，call方法是在FutureTask里的run方法中调用的。那么run方法在哪里得到了执行呢？
这个要从newSingleThreadExecutor方法里开始寻找信息。
public static ExecutorService newSingleThreadExecutor() {
return new FinalizableDelegatedExecutorService
(new ThreadPoolExecutor(1, 1,
0L, TimeUnit.MILLISECONDS,
new LinkedBlockingQueue<Runnable>()));
}
ExecutorService只是一个接口。核心在于ThreadPoolExecutor，他是ExecutorService的实现类，他非常非常的重要。那么ThreadPoolExecutor中的submit方法就是我们的答案。
糟糕的是ThreadPoolExecutor并没有submit方法，那么只能向上寻找， ThreadPoolExecutor继承自AbstractExecutorService。AbstractExecutorService是一个抽象类。那么跟进AbstractExecutorService瞧瞧。然后就找到了submit方法。
submit有三个重载的方法，而在我们刚才的举例中传进的是FutureTask，那么我们需要了解的是这个
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
RunnableFuture<Void> ftask = newTaskFor(task, null);
execute(ftask);
return ftask;
}
好，继续分析
RunnableFuture<Void> ftask = newTaskFor(task, null);这行代码的意义就是保证最终传入execute方法的是RunnableFuture类型的对象。看看newTaskFor方法
protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
return new FutureTask<T>(runnable, value);
}
内部调用的是FutureTask的构造方法。
好，那就看到execute方法了。传进execute方法的是RunnableFuture。
但是AbstractExecutorService并没有实现execute方法，想想也对，Execute应该让具体的子类来实现的。那么回到ThreadPoolExecutor，找到execute方法。谜底快揭晓了
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
/*
* Proceed in 3 steps:
*
* 1. If fewer than corePoolSize threads are running, try to
* start a new thread with the given command as its first
* task. The call to addWorker atomically checks runState and
* workerCount, and so prevents false alarms that would add
* threads when it shouldn't, by returning false.
*
* 2. If a task can be successfully queued, then we still need
* to double-check whether we should have added a thread
* (because existing ones died since last checking) or that
* the pool shut down since entry into this method. So we
* recheck state and if necessary roll back the enqueuing if
* stopped, or start a new thread if there are none.
*
* 3. If we cannot queue task, then we try to add a new
* thread. If it fails, we know we are shut down or saturated
* and so reject the task.
*/
int c = ctl.get();
if (workerCountOf(c) < corePoolSize) {
if (addWorker(command, true))
return;
c = ctl.get();
}
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
else if (!addWorker(command, false))
reject(command);
}
首先我们要先回忆，刚才我们在submit方法中调用execute方法，传入的是RunnableFuture对象。
这里做了一系列的判断，RunnableFuture对象会传进addWorker方法，我们现在看到addWorker方法即可
private boolean addWorker(Runnable firstTask, boolean core) {
//代码省略
Worker w = null;
try {
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
// Recheck while holding lock.
// Back out on ThreadFactory failure or if
// shut down before lock acquired.
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
workers.add(w);
int s = workers.size();
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
抓重点，看看传进的Runnable在哪里使用到了，在这里
w = new Worker(firstTask);
final Thread t = w.thread;
这里Worker又对Runnable进行了包装。Worker的构造方法如下：
Worker(Runnable firstTask) {
setState(-1); // inhibit interrupts until runWorker
this.firstTask = firstTask;
this.thread = getThreadFactory().newThread(this);
}
继续前进，然后w.thread取出Worker里的线程对象并赋值给t变量。
往下看addWorker方法，一系列的判断之后
if (workerAdded) {
t.start();
workerStarted = true;
}在这里调用了Worker里的线程对象的start方法。那么就会执行Worker里面的run方法。如下
/** Delegates main run loop to outer runWorker. */
public void run() {
runWorker(this);
}
run方法内部调用的runWorker方法的源码如下：
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock(); // allow interrupts
boolean completedAbruptly = true;
try {
while (task != null || (task = getTask()) != null) {
w.lock();
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
processWorkerExit(w, completedAbruptly);
}
}
看到这一行代码：
Runnable task = w.firstTask这行代码取出了Worker之前封装的Runnable对象（一开始的FutureTask），并赋值给task，继续看runWorker方法，最终……
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
afterExecute(task, thrown);
}
}
可以看到，task（FutureTask）终于调用run方法。这就是我们一直想寻找的。我们刚开始就想知道，submit提交了FutureTask之后，FutureTask的run方法在哪里被调用了。现在终于明白了。终于海阔天空了。
呼，结束了！我们大致分析了线程池的submit，execute的过程，不说思路很清晰，但是至少心中有数。
相信下一篇终极版会更加的畅快。
扫一扫
593
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
