AsyncTask方法和源码分析

MIRROR1217

于 2018-05-17 17:03:57 发布

阅读量180

点赞数

分类专栏： Android源码解析文章标签： Android AsyncTask 源码解析异步

本文链接：https://blog.csdn.net/mirror1217/article/details/80350170

版权

Android源码解析专栏收录该内容

2 篇文章 0 订阅

订阅专栏

AsyncTask的方法分析

请看下面实例

MyAsyncTask task = new MyAsyncTask();
task.execute("");

public class MyAsyncTask extends AsyncTask<String,Integer,String>{

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
        }

        @Override
        protected String doInBackground(String... params) {
            publishProgress(10)
            return null;
        }

        @Override
        protected void onProgressUpdate(Integer... values) {
            super.onProgressUpdate(values);
        }

        @Override
        protected void onPostExecute(String s) {
            super.onPostExecute(s);
        }

        @Override
        protected void onCancelled() {
            super.onCancelled();
        }
    }

首先，AsyncTask<Params,Progress,Result>的初始化（在此例中，Params泛型是String类型，Progress泛型是Integer类型，Result泛型是String类型）和调用AsyncTask.execute()方法可以不在主线程中完成(Android23之前不行，现在Google添加了@MainThread注解)，并且一个AsyncTask对象只能调用一次execute()方法，原因下面会讲到。初始化进行如下操作：

第一步：会先调用onPreExecute()方法，这个方法将在主线程调用，所以不能在这里开启任务，这里一般进行初始化操作或者设置开始的标志。
第二步：doInBackground()是在子线程中运行的，这里才是我们开启耗时任务的地方，并且将最终的结果返回出去。在doInBanckground()中调用publishProgress(Object)方法,数据将传递到onProgressUpdate()方法中。
第三步：publishProgress(Object)方法是运行在主线程的，得到数据后可以进行UI操作，比如进度条的更新等。
第四步：若调用task.cancel(true)方法取消任务或者发生错误停止任务，将调用onCancelled()方法，否则，在doInBackground()方法中，任务完成后将结果传递到给onPostExecute()方法，我们将在onPostExecute()方法中执行任务完成后的操作。

至此，一个任务完成。下面我们从源码的角度分析AsyncTask.

AsyncTask的源码分析

首先，在AsyncTask开始加载之前，它有一个内部静态代码块，优先于类加载前执行，如下：

    public static final Executor THREAD_POOL_EXECUTOR;

    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    private static final int KEEP_ALIVE_SECONDS = 30;

    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);

static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS,                      TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }

我们可以看到，这里先开始创建一个线程池ThreadPoolExecutor，这个线程池暂时没用到，那么继续往下看：

    public AsyncTask(@Nullable Looper callbackLooper) {
        mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
            ? getMainHandler()
            : new Handler(callbackLooper);

        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;
            }
        };

        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);
                }
            }
        };
    }

在构造方法中我们可以看到，首先对mHandler进行赋值（下面会解释getMainHandler），得到的是主线程的Handler。然后，创建了一个WorkerRunnable，看下WorkerRunnable是什么东东？

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

可以看到，WorkerRunnable是一个静态抽象类，内部实现Callable接口的call（）方法。看下call（）方法内部做了哪些操作：

mTaskInvoked(一个提供原子操作的Integer类)设置为true；
Result设置为null；
setThreadPriority设置线程的优先级为10；
调用doInBackground()方法得到返回值；
Binder的刷新（这个不怎么懂）；
在得到结果后调用postResult(result)方法；

可以看到，这里面有两个重要的步骤，一个是调用doInBackground()方法获取结果，一个调用 postResult(result)方法抛出结果。doInBackground()是我们必须实现的方法，结果也是我们直接返回的。那我们看下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;
    }

可以看到，获取消息并且将消息发送，那么我们继续看下Handler得到消息后怎么处理的？


 private static Handler getMainHandler() {
        synchronized (AsyncTask.class) {
            if (sHandler == null) {
                sHandler = new InternalHandler(Looper.getMainLooper());
            }
            return sHandler;
        }
    }

private static class InternalHandler extends Handler {
        public InternalHandler(Looper looper) {
            super(looper);
        }

        @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;
            }
        }
    }

一开始就提到过,mHandler被赋值，在这儿，我们可以看到使用synchronized进行同步，确保mHandler的唯一性。然后Handler接收到消息（MESSAGE_POST_RESULT）后，将会去调用finish方法，那么看下finish()方法：

 private void finish(Result result) {
        if (isCancelled()) {
            onCancelled(result);
        } else {
            onPostExecute(result);
        }
        mStatus = Status.FINISHED;
    }

可以看到，若任务取消，将调用onCancelled()方法，否则将调用onPostExecute()方法，这个上面就已经提到过了。最后，我们还注意到消息为ESSAGE_POST_PROGRESS时，将调用onProgressUpdate方法。

我们继续分析，WorkerRunable<Params,Result>里面的call（）方法已经分析完成了，我们看下FutureTask<Result>(mWorker)。实际上是将WorkerRunable作为参数传递给了FutureTask(一个可以取消的异步计算，继承Runable和Future)。

上面我们分析到FutureTask了，但它也没开始任务，那么任务是在哪儿开始的呢？实际上，这都是在AsyncTask的构造方法中进行初始化的操作，还没有去执行它（想一想，确实没有线程开始执行对吧！）。那么既然构造中没有执行，肯定是在execute()方法中执行的，我们开始分析execute()方法。

 @MainThread
    public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }

继续看executeOnExecutor方法，

@MainThread
    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;
    }

在这里可以看到，为什么execute（）方法只能调用一次？因为这里会进行一个状态判断，不是PENDING状态下会抛出异常。这里做了那些操作：

mStatus != Status.PENDING:状态判断，抛出错误；
mStatus = Status.RUNNING:将状态设置为RUNNING；
调用onPreExecute()方法；
mWorker.mParams = params:参数赋值；
exec(SerialExecutor):用来管理多线程执行task的一套框架,其实可以将它看作一个串行队列；

首先，执行onPreExecute()方法（这个需要我们自己去实现，不多讲了）。然后，看下exec.execute(mFuture)方法：
```
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();
        }
    }
```
将FutureTask加入到mTasks中，new一个新的线程，在线程中run()方法中执行r.run()方法，实际上就是执行WorkerRunable的call（）方法。注意，这个时候只是开启新线程，线程还没有开始执行，那么线程什么时候开始执行呢？接着看scheduleNext()方法：
```
protected synchronized void scheduleNext() {
        if ((mActive = mTasks.poll()) != null) {
            THREAD_POOL_EXECUTOR.execute(mActive);
        }
    }
```
可以看到，通过将任务赋值给mActive，然后调用THREAD_POOL_EXECUTOR.execute(mActive)方法开始执行任务。关于THREAD_POOL_EXECUTOR,不知道大家还记不记得，我们类加载前初始化的一个线程池，就是它，只不过到这里才用到它。