AsyncTask 源码分析

转载请注明出处：http://blog.csdn.net/vnanyesheshou/article/details/73743534

本文已授权微信公众号 fanfan程序媛独家发布扫一扫文章底部的二维码或在微信搜索 fanfan程序媛即可关注

上一篇主要说了下AsyncTask的基本用法和注意事项。这篇主要从源码的角度研究下AsyncTask的原理。

先说下AsyncTask类中表示状态的一个枚举类，代码如下：

public enum Status {
    PENDING,
    RUNNING,
    FINISHED,
}

PENDING 表示尚未执行任务。
RUNNING 表示任务正在运行。
FINISHED 表示任务结束。
AsyncTask中有一个Status类型变量mStatus，初始值为PENDING。
接着分析任务的执行方法，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;
}

第6行：首先判断mStatus 的值，如果为PENDING则向下运行，设置mStatus为RUNNING；否则抛出异常。也就是说每个异步任务只能执行一次，多次运行会抛出异常。
第18行：调用onPreExecute()函数。这是在UI线程中。
第19行：将参数赋值给mWorker.mParams。
第20行： exec.execute(mFuture)。
这里的mWorker、exec（sDefaultExecutor）、mFuture看的比较模糊。我们看一下AsyncTask构造函数

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

            Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
            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);
            }
        }
    };
}

mWorker是WorkerRunnable类型实例，WorkerRunnable代码如下：

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

WorkerRunnable类是AsyncTask内部的一个抽象类，它实现了Callable接口，其中参数mParams用来保存传入的参数。mWorker实现了Callable中的call()方法。Callable类似于Runnable的接口，实现Callable接口和Runnable都是可被其他线程执行的任务。
Callable定义的方法是call，Runnalbe定义的是run。
mWorker 的call方法中设置线程优先级为后台级别。然后调用AsyncTask的doInBackground方法（在子线程中）。

mFuture是FutureTask的实例（java.util.concurrent.FutureTask）,FutureTask是一个可以中途取消的异步计算类。mFuture实例中，将会调用mWorker做任务，完成后会调用其done方法。

exec是由函数execute(Params…）传过来的参数sDefaultExecutor。sDefaultExecutor的初始化如下：

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_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);
        }
    }
}

sDefaultExecutor 是SerialExecutor的实例，SerialExecutor实现了Executor接口，该类中有一个任务队列，任务执行execute，然后 exec.execute(mFuture)会调用到SerialExecutor的execute方法。
第9行将任务添加到任务队列中。
第14行该任务执行完后，调用scheduleNext，执行下一个任务。
第18行判断mActive 是否为null，为空则调用scheduleNext。这表示任务是一个一个执行（串行）。
scheduleNext函数从任务队列取出首任务，如果不为null，则传入THREAD_POOL_EXECUTOR执行该任务。

多个任务依次调用execute方法。第一个任务入队，mActive 为null，执行scheduleNext，从队列中取出第一个任务，交给线程池去执行。第二个任务入队，mActive此时不为空，所以先不执行该任务。之后的各个任务也都添加到队列中，不会串行执行。前面的任务执行完后，会执行Runnable中的finally代码块中的scheduleNext函数，然后从队列中取出任务，交给线程池执行。

接着看THREAD_POOL_EXECUTOR：

private static final int CORE_POOL_SIZE = 5;
private static final int MAXIMUM_POOL_SIZE = 128;
private static final int KEEP_ALIVE = 1;
//线程工厂
private static final ThreadFactory sThreadFactory = new ThreadFactory() {
    private final AtomicInteger mCount = new AtomicInteger(1);

    public Thread newThread(Runnable r) {
        return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
    }
};
//队列 存放线程。
private static final BlockingQueue<Runnable> sPoolWorkQueue =
        new LinkedBlockingQueue<Runnable>(10);
public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

THREAD_POOL_EXECUTOR是新建的一个线程池执行器，用于管理线程的执行。

接着看mFuture。
mFuture的done()方法中，如果任务顺利完成，则调用postResultIfNotInvoked(get())，get()方法用来获取执行任务的结果；如果捕捉到CancellationException则调用postResultIfNotInvoked(null)。
接着看postResultIfNotInvoked

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

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

postResultIfNotInvoked函数调用postResult函数。

第10行创建AsyncTaskResult对象，保存异步任务的结果及对应的任务。
第11行将message发送给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:
                result.mTask.finish(result.mData[0]);
                break;
            case MESSAGE_POST_PROGRESS:
                result.mTask.onProgressUpdate(result.mData);
                break;
        }
    }
}

接收到MESSAGE_POST_RESULT消息，调用AsyncTask的finish方法。

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

第2行，判断任务是否取消，如果取消则回调onCancelled(Result)方法。否则调用onPostExecute(Result)方法。
第7行，将任务状态设置为FINISHED。

publishProgress

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

通过调用publishProgress来更新任务进度。该方法中先判断任务是否取消，如果取消则不在处理。否则向Handler发送消息。
Handler接收到MESSAGE_POST_PROGRESS消息后，调用AsyncTask的onProgressUpdate()方法，更新进度。

到此AsyncTask就说的差不多了。AsyncTask是对线程池、Handler的良好封装，是我们使用更加简单方便。但是AsyncTask使用也有一定的缺陷，长时间的任务不建议使用AsyncTask。

欢迎扫一扫关注我的微信公众号，定期推送优质技术文章：

zpy_公众号_码农修仙儿博客专家

发布了129 篇原创文章 · 获赞 270 · 访问量 97万+

私信关注

AsyncTask 源码分析

模拟手机设备：使用 Playwright 实现移动端自动化测试

Mellanox网卡开启SR-IOV

全面系统的AI学习路径，帮助普通人也能玩转AI

uni-app实现上拉加载

vue3编译优化之“静态提升”

又是一个月-20240513

flask 如何保证返回json有序

linux服务器设置ssh免密

HTML 00 Tutorial

apisix~lua插件开发与插件注册

Android 四大組件（二）Service

Android 數據存儲（一）SharedPreferences

Android WiFi開發（三）Wifi熱點8.0適配

AsyncTask 異步任務基本使用－－下載視頻

Android 藍牙開發（十一）Pan藍牙共享網絡分析

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結