AsyncTask源码分析

首先看AsyncTask的execute

为啥一个任务实例只能执行一次，如果执行第二次将会抛出异常

看下面的代码，一共有三种状态PENDING（尚未执行），RUNNING（执行中），FINISHED（已经执行完），只有是未执行则开始执行，否则是执行中或是已经执行完则抛异常．

       
 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;

可以看到在execute中执行了onPreExecute（）方法，说明onPreExecute也运行在主线程中

可以看到mWorker存储了execute传过来的参数，mWorker是WorkerRunnable类型的，而WorkerRunnable实现了Callable，

Callable类似于Runnable的接口，都是可被其它线程执行的任务，mWorker在AsyncTask的构造方法里被初始化，可以看到call里执行了doInBackground，所以就从主线程执行到了子线程

mWorker.mParams = params;

private final WorkerRunnable<Params, Result> mWorker;

private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }

 mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                Result result = null;
                try {
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    //noinspection unchecked
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    postResult(result);
                }
                return result;
            }
        };

exec.execute(mFuture);是线程池，每execute一次会从线程池中取出一个线程执行

mFuture的声明private final FutureTask<Result> mFuture

FutureTask可以用来封装一个Runnable或者Callable任务，并异步执行，当用户想要返回的结果时，只需要调用get方法获取。

FutureTask继承了RunnableFuture接口，它可以直接作为一个Runnable或Callable提交到线程池执行。

在下面的初始化中new FutureTask<Result>(mWorker)可以看到保存了mWorker

也就是说exec.execute(mFuture);这句话就是要执行mFuture的run方法，run方法中result = c.call();这句话就调到了mWorker的call方法，然后就执行了doInBackground，然后将doInBackground执行结果保存在result中，run方法中还有句set(result),set中调用了done方法，这个done方法会被调用，就会执行下面的done方法．（加粗字体的是java的知识）

 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 occurred while executing doInBackground()",
                            e.getCause());
                } catch (CancellationException e) {
                    postResultIfNotInvoked(null);
                }
            }
        };

然后继续执行，最后走到result.mTask.onProgressUpdate(result.mData);因此通过handler发消息将结果返回到主线程．执行了onProgressUpdate，如果finish则执行onPostExecute

    private void postResultIfNotInvoked(Result result) {
        final boolean wasTaskInvoked = mTaskInvoked.get();
        if (!wasTaskInvoked) {
            postResult(result);
        }
    }

    private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }       
 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;
    }

值得注意的是AsyncTask三种泛型类型分别代表“启动任务执行的输入参数”、“后台任务执行的进度”、“后台计算结果的类型”。在特定场合下，并不是所有类型都被使用，如果没有被使用，可以用java.lang.Void类型代替。