android AsyncTask详解

下面的按AysncTask的执行步骤来分析:

1,创建实例并传入paramter
//注意每次需new一个实例,新建的任务只能执行一次,否则会出现异常   
mTask = new MyTask();   //MyAsyTask extends AsyncTask
1.1new MyTask()将执行下面的代码:执行初始化工作

public AsyncTask() {

//工作类

        mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);

               Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);

              //noinspection unchecked

//因为doInBackground(mParams)在后台线程执行的,也就是在子线程里面执行,也就是说mWorker的call()方法将会被子线程的run方法调用

//下面mFuture就是impletement Runnable的子线程，我们将看到call()被mFuture的run方法调用

                return postResult(doInBackground(mParams));
            }

        };

/**创建FutureTask的实例*/

        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);
                }
            }
        };
    }
1.2传入参数，并执行任务
mTask.execute("http://www.baidu.com");

2, execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
}

2.1 sDefaultExecutor:为一个默认执行器下面是实现
 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 {

/**执行传入的Runnable实例mFuture的rum方法*/

//3.2是mFuture的run方法内部，顺着下去我们就可以看到mWorker的call()方法

//被调用(3.3)

                        r.run(); 
                    } finally {
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }


        protected synchronized void scheduleNext() {
            if ((mActive = mTasks.poll()) != null) {
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }
2.2 executeOnExecutor(Executor exec, Params... 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;
/**执行器执行传的Runnalbe实例*/
        exec.execute( mFuture);
        return this;
    }

2.3 mFuture 是FutureTask实例，而FutureTask间接实现Runnable 在第1步时实创建了mFuture
    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));
            }
        };
/**创建FutureTask的实例*/
        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);
                }
            }
        };
    }

  2.4, 执行：exec.execute(mFuture)：也就是执行2.1SerialExecutor的execute(final Runnable r)方法:
mFuture的run方法被执行,查看run方法的内容:

3. mWorker方法是如何被执行的

3.1 WorkerRunnable 实现在Callable 在1.1把mWorker实例传入
public FutureTask(Callable<V> callable) {
        if (callable == null)
            throw new NullPointerException();
        sync = new Sync(callable);

    }

3.2在2.4执行Future的Run方法，也就是下面的方法:从3.3中可以看到mWorker的代码(1.1那里),是在子线程执行的
public void run() { / /这是Future的run方法子线程代码
        sync.innerRun();

    }

3.3 mWorker(即callable)的实现方法将在下面call()方法执行:回到1.1查看mworker的call()方法
void innerRun() {
            if (!compareAndSetState(READY, RUNNING))
                return;


            runner = Thread.currentThread();
            if (getState() == RUNNING) { // recheck after setting thread
                V result;
                try {
/**mWorker的call方法被执行*/
                    result = callable.call();
                } catch (Throwable ex) {
                    setException(ex);
                    return;
                }
                set(result);
            } else {
                releaseShared(0); // cancel
            }

        }

 4,查看mWorker的call()方法内部

4.1  mWorker = new WorkerRunnable<Params, Result>() {

/**该方法被Future的run方法调用，所有在子线程中运行*/
            public Result call() throws Exception {
                mTaskInvoked.set(true);


                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                //noinspection unchecked
                return postResult(doInBackground(mParams));//后台(子线程内执行的方法)方法被执行了
            }
        };
4.2 postResult(doInBackground(mParams));:把给封装到Message中并发送到handler中
private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }
4.3handler 是静的，所有在主线程中new Asytask时，handler默认与主线程的looper关联
下面可看到两个在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
/**finish内部将调用 onPostExecute(result)*/
                    result.mTask.finish(result.mData[0]);
                    break;
                case MESSAGE_POST_PROGRESS:
/**调用进度方法*/
                    result.mTask.onProgressUpdate(result.mData);
                    break;
            }
        }
    }

4.4 发送进度msg：MESSAGE_POST_PROGRESS；我在可以中doInBackGroud()内执行该通知onProgressUpdate(result.mData);
protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
                   new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }