Android之AsyncTask源码解析

转载请标明出处:【顾林海的博客】

个人开发的微信小程序,目前功能是书籍推荐,后续会完善一些新功能,希望大家多多支持!
在这里插入图片描述

##前言

AsyncTask是一种轻量级的异步任务类,内部封装了Thread和Handler,通过AsyncTask执行后台任务以及在主线程中访问UI控件,但AsyncTask在Android 1.6之前是串行任务,在Android 1.6时AsyncTask采用线程池处理并行任务,又在Android 3.0开始采用一个线程串行执行任务,所以在使用AsyncTask时需要根据具体的场景来选择是否使用AsyncTask,比如需要与主线程有交互可以使用AsyncTask,否则就使用线程,如果需要执行大量线程执行任务时推荐使用线程池,AsyncTask的使用方式并不会讲解,这个大家可以在网上随便搜搜,文章主要围绕AsyncTask的源码来解析执行的流程。

##源码解析

在使用AsyncTask时,需要重写它的几个方法,其中doInBackground(Params… params)方法必须实现,该方法用于执行异步任务,参数params表示异步任务的输入参数,在这个方法中可以通过publishProgress方法来更新任务进度,publishProgress方法会调用onProgressUpdate方法,改方法在主线程中执行;如果需要在执行异步之前做一些初始化操作,比如显示一个进度条,可以重写它的onPreExecute方法,这个方法执行在主线程;当doInBackground方法执行完毕,如果需要异步任务数据返回给主线程,可以重写onPostExecute(Result result)方法,这个方法在主线程中执行,参数result是后台返回的值,也就是doInBackground方法返回的值,那么AsyncTask整体执行的流程可以用下面的图来表示。

这里写图片描述

执行AsyncTask的方法是execute,贴出其中一个execute方法源码:

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

在执行AsyncTask的execute(Params… params)方法时,内部会去执行executeOnExecutor方法,其中的参数sDefaultExecutor是AsyncTask内部类SerialExecutor的实例,是一个串行的线程池,SerialExecutor实现Executor接口并实现Executor接口中的execute(Runnable command)方法,用于执行已经提交的Runnable任务对象,SerialExecutor这个内部类的具体实现可以通过下面的源码来得知。

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


public static final Executor THREAD_POOL_EXECUTOR;

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

SerialExecutor类中定义了一个ArrayDeque,它是一个先进先出的队列,在execute方法中通过scheduleNext方法从队列中取出Runnable对象,并通过THREAD_POOL_EXECUTOR来执行,THREAD_POOL_EXECUTOR是线程池。上面的SerialExecutor是用于任务的排队,而线程池THREAD_POOL_EXECUTOR才是执行任务的,关于SerialExecutor的介绍暂时就到这里,我们会到上面的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;
}

通过execute(Params… params)方法执行executeOnExecutor(Executor exec,Params… params)方法,在一开始会对当前的执行的状态进行判断,Status是一个枚举类,内部提供了三种状态,分别是FENDING(表示尚未执行)、RUNNING(表示任务正在执行)和FINISHED(表示任务执行结束),AsyncTask内部在执行任务前会去判断当前任务的执行状态,当任务正在执行或是已经执行结束会抛出异常,当新任务开始时mStatus为RUNNING,表示开始执行异步任务,接着会调用onPreExecute()方法,这时还没有执行异步任务,所以onPreExecute方法在主线程中执行。
onPreExecute方法执行完毕后,会将我们传入的Params参数封装成FutureTask对象,其中的mWorker是内部静态类WorkerRunnable,源码如下。

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

WorkerRunnable实现了Callable接口,用于获取异步任务执行完毕后的数据,上面的mWorker和mFuture在AsyncTask初始化时进行初始化,看下面的源码。

public AsyncTask() {
    this((Looper) null);
}

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

    mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
            mTaskInvoked.set(true);//————2
            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);
            }
        }
    };
}

上面1处代码判断callbackLooper是否空或是主线程的Looper,这个因为传入的是null,最终调用的是getMainHandler方法,用于创建Handler,这部分后面会讲到,继续看mWorker的实例化时实现了call方法,并返回异步任务执行结果Result,这里又看到一个熟悉的方法doInBackground方法,这个方法执行在异步线程中,mFuture在实例化时将mWorker作为参数并实现了done方法,可以看到内部通过get()方法获取mWorker的call方法的返回值,并传递给postResultlfNotInvoked方法,这里看下它的源码。

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

mTaskInvoked是AtomicBoolean类型,在上面执行mWorker的call方法时(代码2处)mTaskInvoked设置为true,因此这里的判断语句不成立,就不继续往下看了,回到上面的mWorker初始化的地方,这里为了大家方便查看,再次把相关源码贴下:

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

在执行完doInBackground方法后会返回Result,最后会执行finally语句块中的postResult方法,查看该方法源码:

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

很明显通过Handler来发送消息,找找Handler的定义的地方,还记得我们在上面介绍AsyncTask初始化时讲到传入的参数callbackLooper为空,就调用getMainHandler方法,也就是说这里的发送消息的Handler就是在getMainHandler方法中初始化的,查看getMainHandler方法源码。

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

InternalHandler是AsyncTask的内部静态类并继承自Handler。

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

之前在doInBackground方法执行完毕后会将Result和MESSAGE_POST_RESULT通过Handler发送给主线程,在handleMessage方法中将我们的Result包装成AsyncTaskResult类型,AsyncTaskResult内部有个Data范型数组,数组的第一个就是异步任务执行的结果,这里将结果传递给finish方法。

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

在这里又看到一个熟悉的方法onPostExecute方法,这个方法是执行在主线程中的用于与UI交互,执行完onPostExecute方法后会将mStatus设置为FINISHED,说明此次异步任务执行完毕。到这里onPreExecute、doInBackground和onPostExecute方法执行时机都已经讲解清楚了,剩下的就是onProgressUpdate方法的执行时机,从前面知道在doInBackground方法中执行publishProgress方法会执行onProgressUpdate方法,查看publishProgress方法源码。

protected final void publishProgress(Progress... values) {
    if (!isCancelled()) {
        getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                new AsyncTaskResult<Progress>(this, values)).sendToTarget();
    }
}

在这里也是通过Handler来发送消息给主线程来执行onProgressUpdate方法。

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

发送消息到主线程后会执行onProgressUpdate方法,这也说明了onProgressUpdate是执行在主线程中。

在这里提一下,之前在前言中讲过由于Android版本的不同,AsyncTask内部执行的机制也不同,这里AsyncTask新增了一个方法executeOnExecutor(Executor exec,Params… params)用于开发者自己定义线程池。

©️2020 CSDN 皮肤主题: 猿与汪的秘密 设计师:上身试试 返回首页