Asynctask

底层：handler + 线程池

• Asynctask 的实例必须在主线程中创建
• Asynctask 的execute方法必须在主线程中调用
• 回调方法，Android会自动调用
• 一个AsyncTask 的实例，只能执行一次execute方法，否则会抛出异常

CPU_COUNT : CPU的核数
AsyncTask所使用的线程数的核心大小：CPU_COUNT + 1
AsyncTask线程池最大线程数：CPU_COUNT *2+1
ThreadPoolExecutor: AsyncTask 内部维护的是一个静态线程池
SerialExecute是一个内部类，他实现了 Execute 接口当中的 execute 方法，这个类是执行串行的任务，一个接一个执行。在源码中我们可以看到在 AsyncTask 内部最终还是要通过默认的线程池 THREAD_POOL_EXECUTOR 来执行操作。

private static class SerialExecutor implements Executor {
    final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
    Runnable mActive;

    public synchronized void execute(final Runnable r) {
        mTasks.offer(new Runnable() {
            public void run() {
                try {
                    r.run();
                } finally {
                    scheduleNext();
                }
            }
        });
        if (mActive == null) {
            scheduleNext();
        }
    }

    protected synchronized void scheduleNext() {
        if ((mActive = mTasks.poll()) != null) {
            THREAD_POOL_EXECUTOR.execute(mActive);
        }
    }
}

AsyncTask 的三种状态

• PENDING, 默认状态

• RUNNING,运行状态

• FINISHED,停止状态

    public AsyncTask() {
    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            mTaskInvoked.set(true);
  
            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
            //noinspection unchecked
            return postResult(doInBackground(mParams));
        }
    };
  
    mFuture = new FutureTask<Result>(mWorker) {
        @Override
        protected void done() {
            try {
                postResultIfNotInvoked(get());
            } catch (InterruptedException e) {
                android.util.Log.w(LOG_TAG, e);
            } catch (ExecutionException e) {
                throw new RuntimeException("An error occured while executing doInBackground()",
                        e.getCause());
            } catch (CancellationException e) {
                postResultIfNotInvoked(null);
            }
        }
    };
  }
  

• 我们来看Asynctask的构造方法， WorkerRunnabler是什么呢？通过源码我们发现WorkerRunnabler实现了 Callable类。我们接着看Call方法里的mTaskInvoked.set(true);这句话的意思表明该任务已经开始被执行了。
  Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);这句表示将我们的call方法线程改成后台线程级别。之后再看postResult(doInBackground(mParams))。他会做doinBackground做一些耗时操作。之后把返回结果result返回来调用postResult方法。

private Result postResult(Result result) {
    @SuppressWarnings("unchecked")
    Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
            new AsyncTaskResult<Result>(this, result));
    message.sendToTarget();
    return result;
}

• 在这里我们看到我们把消息发送给了handler，那么handler又是怎么做的呢？

private static class InternalHandler extends Handler {
    @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})
    @Override
    public void handleMessage(Message msg) {
        AsyncTaskResult result = (AsyncTaskResult) msg.obj;
        switch (msg.what) {
            case MESSAGE_POST_RESULT:
                // There is only one result
                result.mTask.finish(result.mData[0]);
                break;
            case MESSAGE_POST_PROGRESS:
                result.mTask.onProgressUpdate(result.mData);
                break;
        }
    }
}
private void finish(Result result) {
    if (isCancelled()) {
        onCancelled(result);
    } else {
        onPostExecute(result);
    }
    mStatus = Status.FINISHED;
}

这里的result.mTask 就是我们的所绑定的Asynctask而那个reslut.mData[0]就是doinbackground所返回的那个处理结果，之后我们看finish方法。他首先会判断这个任务是否被取消。 如果没被取消会调用onPostExecute方法。最后将状态值改成finish表示该任务已完成。可以进行下一个任务。

我们接着往下看FutureTask 内部实现了 runnable 接口，所以我们可以直接它传递给我们的线程池execute，让线程池去执行操作。FutureTask 内部有一个done方法。这个done方法呢由我们自己实现，可以用来做一些数据的回显，数据的保存等等，还有一个get方法这个get方法阻塞式的等待call方法的返回值，如果任务执行完了，他就立即返回执行的结果，否则就会阻塞式的等待call方法的完成。当然还有一个cancel方法。用来取消任务。任务取消后还是会执行done方法。

最后我们来看一下线程池的execute方法。

    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    return executeOnExecutor(sDefaultExecutor, params);
    }
    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
        Params... params) {
    if (mStatus != Status.PENDING) {
        switch (mStatus) {
            case RUNNING:
                throw new IllegalStateException("Cannot execute task:"
                        + " the task is already running.");
            case FINISHED:
                throw new IllegalStateException("Cannot execute task:"
                        + " the task has already been executed "
                        + "(a task can be executed only once)");
        }
    }

    mStatus = Status.RUNNING;

    onPreExecute();

    mWorker.mParams = params;
    exec.execute(mFuture);

    return this;
}

我们可以看到他将sDefaultExecutor给了这个方法。所以说sDefaultExecutor就是默认执行任务的线程池。
我们一步步往下看。它首先会对mStatus的状态进行判断，只有在PENDING状态的情况下。他才会执行下去。
之后将状态改成RUNNING，之后执行onPreExecute方法。这个方法中我们可以执行一些初始化的操作。这个方法是运行在主线程当中的。所以我们可以做一些UI的改变。exec.execute(mFuture);这个mFuture是我们FutureTask的实例。之前说过了FutureTask 实现了runnable接口。所以exec，也就是我们的线程池可以直接调用execute方法来执行我们的线程。

public interface Callable<V> {
/**
 * Computes a result, or throws an exception if unable to do so.
 *
 * @return computed result
 * @throws Exception if unable to compute a result
 */
V call() throws Exception;
}

public interface Runnable {

/**
 * Starts executing the active part of the class' code. This method is
 * called when a thread is started that has been created with a class which
 * implements {@code Runnable}.
 */
      public void run();
}

• 顺便多一嘴 Callable跟我们很熟悉的Runnable有点像，但是他两之间有一个区别。我们发现call方法有返回参数V 而run方法没有。