AsyncTask源码分析

2401_84692253

于 2024-05-16 06:32:40 发布

阅读量696

点赞数 10

文章标签： java 面试学习

本文链接：https://blog.csdn.net/2401_84692253/article/details/138939004

版权

总结

本文从基础到高级再到实战，由浅入深，把MySQL讲的清清楚楚，明明白白，这应该是我目前为止看到过最好的有关MySQL的学习笔记了，我相信如果你把这份笔记认真看完后，无论是工作中碰到的问题还是被面试官问到的问题都能迎刃而解！

MySQL50道高频面试题整理：

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

Void onPreExecute()

在task 任务开始执行的时候调用，在doInBackground(Params… params)方法之前调用，在主线程中执行

- Result doInBackground(Params… params)

主要用来执行耗时操作，在子线程中执行，Params为我们参数的类型。而Result这个泛型，是我们返回的类型（可以是Integer，Long，String等等类型，只要不是八种基本类型就OK），同时 Result 的类型将作为 onPostExecute(Result result)的参数。

Void onProgressUpdate(Progress… values)

Runs on the UI thread after publishProgress(Progress…) is invoked. 当我们调用 publishProgress（）方法的时候，会调用 onProgressUpdate（）这个方法

Void onPostExecute(Result result)

在doInBackground（）方法执行完毕之后，会调用这个方法，是在主线程中执行的。但如果我们手动调用了cancelled()方法，那么这个方法将不会被调用。

void onCancelled()

在Task

execute(Params… params)

Executes the task with the specified parameters.当我们调用这个方法的时候，会执行任务

executeOnExecutor(Executor exec, Params… params)

在指定的线程池里面执行Task

需要注意的是，Params，Progress，Result 并不是一种特定的类型，它其实是泛型，它支持除了八种基本类型之外的类型，跟普通的泛型一样。

AsyncTask 的源码分析

执行流程

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

当我们调用 execute（）方法的时候，会紧接着调用我们的execeteOnExecutor（sDefaultExecutor, params）方法

在这个方法里面，会首先判断执行的状态的合法性，如果是finish或者running，会抛出异常，这也就是为什么AsyncTak只能被调用执行一次。紧接着会调用onPreExecute()方法

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;

}

接着会把当前的状态设置running状态，并把我们的params传递给我们的mWork。params=params；

那这个mWork是什么呢？

public AsyncTask() {

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

}

};

}

我们先来分析一下mWorker;

mWorker为AsyncTask的一个内部类

，实现了Callable接口，在call方法里面会调用我们的doInBackground方法，这也就是为什么我们的doInBackground。方法是在子线程里面执行的，执行完doInBackground（）方法会把结构传递给我们的postResult（result）方法，在result方法，会调用handler发送消息，

接着再handler的handleMessage里面处理，在handleMessage里面，又会调用我们的 finish()方法,finish()方法里面会判断任务是否取消，如果被取消，会调用onCancelled（），否则会调用onPostExecute（）方法。

private static class InternalHandler extends Handler {

public InternalHandler() {

super(Looper.getMainLooper());

}

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

}

private void finish(Result result) {

if (isCancelled()) {

onCancelled(result);

} else {

onPostExecute(result);

}

mStatus = Status.FINISHED;

}

接着我们来分析一下mFuture

mFuture = new FutureTask(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);

}

};

postResultIfNotInvoked(get());get()表示获取mWorker的call的返回值，即Result。
然后看postResultIfNotInvoked方法。会判断是否已经将结果发送出去，即判断在mWork里面是否已经调用postResult(result)发送结果，没有的话调用再调用postResult(result)发送出去

private void postResultIfNotInvoked(Result result) {

final boolean wasTaskInvoked = mTaskInvoked.get();

if (!wasTaskInvoked) {

postResult(result);

}

还记得上面exec.execute()吗？exec为executeOnExecutor(sDefaultExecutor,params)中的sDefaultExecutor

下面看这个sDefaultExecutor

private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

private static class SerialExecutor implements Executor {

final ArrayDeque mTasks = new ArrayDeque();

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的一个实例，其内部维持一个任务队列；直接看其execute（Runnable runnable）方法，将runnable放入mTasks队尾；

判断当前mActive是否为空，为空则调用scheduleNext方法

scheduleNext方法里面，则直接取出任务队列中的队首任务，如果不为null则传入THREAD_POOL_EXECUTOR进行执行。

下面看THREAD_POOL_EXECUTOR为何方神圣：

Public static final Executor THREAD_POOL_EXECUTOR

=new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,

TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

可以看到就是一个自己设置参数的线程池，参数为：

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 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 sPoolWorkQueue =

new LinkedBlockingQueue(128);

回顾一下sDefaultExecutor，真正在execute()中调用的为sDefaultExecutor.execute：

private static class SerialExecutor implements Executor {

final ArrayDeque mTasks = new ArrayDeque();

Runnable mActive;

public synchronized void execute(final Runnable r) {

mTasks.offer(new Runnable() {

public void run() {

try {

r.run();