Android中的线程池（一）

一直想写关于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的过程，不说思路很清晰，但是至少心中有数。

相信下一篇终极版会更加的畅快。