本文出自博客Vander丶CSDN博客，如需转载请标明出处，尊重原创谢谢
博客地址：http://blog.csdn.net/l540675759/article/details/62893318
写作背景
愚人节特别篇
这篇博客准备了好久,一直放在草稿箱里面,随着之前的深入了解Android线程池 . 完结之后,在写这篇文章就顺手了非常多.
写这篇博客的时候,仅仅想了解下AsyncTask,没想到看着源代码之后就沉迷了,一点一点看了队列,同步,异步,也尝试着翻译英文文档,总之收货满满.
本文用图,所有为本人独立创作,假设转载请注明出处,请尊重原创谢谢.
本文大部分观点,属于博主个人观点,如有错误,希望大家多多指正,然后博主及时更改.
最后希望看到博主文章的小伙伴,能够给博主顶一顶博客,欢迎留言,欢迎讨论.
前言：
本篇文章主要介绍AsyncTask的内部工作原理
在阅读文本之前,假设你不太了解AsyncTask,能够先參考我的博客AsyncTask(异步任务）分析之基本使用
文中涉及到一些术语如:串行、并行、队列这些关键词会在导读中为大家介绍
导读：
AsyncTask的组成非常easy。可是还有有一些关键的知识点，导读中将会把一些比較重要的概念整理出来。让大家提前了解下，会使接下来的阅读更顺畅。
串行和并行的概念
在Android3.0之前，AsyncTask一直是并行运行的。而在Android3.0之后更改为串行运行，假设对串行和并行概念不太了解。能够參阅下我之前的线程中同步、异步、串行、并行这篇文章，通过图能让你迅速了解串行和并行的基本概念。
Android的消息机制，Handler的原理
在AsyncTask的工作原理中，InternalHandler是其运转的主要一环。AsyncTask通过它，来保持和UI线程的通信。从而实现进度的更新，以及AsyncTask的回调、中断的通知。
假设对Handler机制不太熟悉。能够參考下android的消息机制——Handler机制这篇文章。
队列的概念。容器ArrayDeque的使用
在AsyncTask中，有一个双端队列的线程池。通过其来保持AsyncTask的调度，而其内部的容器就是ArrayDeque。对于ArrayDeque网上的介绍比較少，这里能够參考我整理的深入了解双端队列Deque能够大致了解ArrayDeque的结构。
Android中的线程池
AsyncTask中採用线程池用于任务的调度和运行,假设对线程池不太了解,能够參考我的博文深入了解Android线程池 .
AsyncTask的源代码解析
AsyncTask的主要成员
从AsyncTask的内部模块图能够看出,AsyncTask主要分为下面几个模块 :
(1)用于任务的调度的线程池SerialExecutor,图中的任务队列池.
(2)用于任务的运行的线程池ThreadPoolExecutor,图中的运行任务的线程池.
(3)用于和UI线程交互的InternalHandler,通知任务的完毕的进度,以及任务的一些状态.AsyncTask的状态
public enum Status {
/**
* AsyncTask的初始状态,表明AsyncTask处于未运行任务的状态
*/
PENDING,
/**
* AsyncTask的运行状态,表明AsyncTask正在运行任务,正在运行
*/
RUNNING,
/**
* AsycnTask的完毕状态,表明AsyncTask处于完毕状态,而且会调用onPostExecute
*/
FINISHED,
}任务调度线程池SerialExecutor
我们能够看到SerialExecutor仅仅是实现了Executor这个接口,其内部维持的队列是ArrayDeque(一种双向队列).它会在一个任务运行结束,和SerialExecutor初始化之后,会自己主动去队列中获取任务并通过THREAD_POOL_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);
}
}
}任务的运行的线程池THREAD_POOL_EXECUTOR
运行线程池的初始化过程:
//获得当前CPU的核心数
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
//设置线程池的核心线程数2-4之间,可是取决于CPU核数
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
//设置线程池的最大线程数为 CPU核数*2+1
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
//设置线程池空暇线程存活时间30s
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());
}
};
//初始化存储任务的队列为LinkedBlockingQueue 最大容量为128
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
/**
* 一个能够运行并行任务的线程池哦
*/
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);
//设置核心线程池的 超时时间也为30s
threadPoolExecutor.allowCoreThreadTimeOut(true);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
用于和UI交互的InternalHandler
private static class InternalHandler extends Handler {
//注意:这里是获取主线程的Looper(),也就是为什么AsyncTask能和主线程交互的原因
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:
//这里将结果通过Handler传递到主线程
result.mTask.finish(result.mData[0]);
break;
case MESSAGE_POST_PROGRESS:
//这是是通知主线程更新进度的操作.
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
AsyncTask的内部模块图
上图是AsyncTask的内部模块图。通过此图大家能够了解AsyncTask简单的工作原理。
AsyncTask的构造方法
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);
//运行异步操作
result = doInBackground(mParams);
//将进程中未运行的命令,一并送往CPU处理
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 {
//在运行完任务做一道检查,将没被调用的Result也一并发出.
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) {
//假设发生异常,则将结果滞null发出.
postResultIfNotInvoked(null);
}
}
};
}在AsyncTask的构造方法中,将任务包装好,然后进行初始化操作:
在构造方法中,WorkerRunnable就一个能储存參数的Callable.
//这里的Callable也是任务,可是与Runnable不同的是,Callable<T>存在返回值,返回值就为其泛型
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
而FutureTask也是一个包装类,我们来看下FutureTask的构造方法:
//事实上FutureTask内部包括Callable<T>,而且添加了一些状态标识和暴漏出操作Callable<T>的一些接口.
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW;
}
而其done()方法,就是FutureTask内的Callable运行完毕之后的调用方法.在done()方法中,对任务的调用进行复查,将未被调用的任务的结果通过InternalHandler传递到UI线程.
//方法非常easy,就是取得标志,然后推断该标志而已,复查没有被调用的任务,将其Result对象发送出去.
private void postResultIfNotInvoked()(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
//假设没有被运行,也须要把结果发送出去.
if (!wasTaskInvoked) {
postResult(result);
}
}AsyncTask的工作原理
通过上面的介绍,我们了解了AsyncTask的核心组成,以及AsyncTask在初始化所做的操作.
execute()
那么接下来,我们来一起看下AsyncTask的工作原理,这里我们从AsyncTask的运行方法execute()開始:
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
//从这里我们发现终于调用的方法是executeOnExecutor()方法
//此时是通过队列线程池储存任务,然后运行线程池取出任务运行.
return executeOnExecutor(sDefaultExecutor, params);
}executeOnExecutor()
@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
//推断AsyncTask当前的运行状态,PENDING为初始化状态
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)");
}
}
//executeOnExecutor()被调用时,AsyncTask的状态就变成了RUNNING状态
mStatus = Status.RUNNING;
//此时进行准备工作(主线程)
onPreExecute();
//将參数加入到任务中
mWorker.mParams = params;
//运行任务
exec.execute(mFuture);
return this;
}AsyncTask的基本运行流程大致的情况,上面已经介绍,须要注意的是,在Android3.0之前AsyncTask是并行运行的.
而在Android3.0之后默认AsyncTask是串行运行的.关于线程的串行和并行这里假设不明确,能够參考导读.详细大家能够在Android模拟器分别在3.0下面和3.0以上的版本号进行測试.
而假设在Android3.0以上的版本号并行运行AsyncTask,我们能够这样:
@Override
protected void onPostExecute(Void aVoid) {
super.onPostExecute(aVoid);
Log.d(TAG, "异步任务完毕阶段阶段");
SimpleDateFormat df =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Log.d(TAG, "当前异步任务 : "+" "+ this.hashCode()+"" );
Log.d(TAG, "当前结束时间 : "+" "+df.format(new Date()) );
}//这里直接调用executeOnExecutor()方法,而且制定处理的线程池为 //AsyncTask.THREAD_POOL_EXECUTOR,也就是运行线程池
new
TestAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "");
new TestAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "");
new TestAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "");
new TestAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, "");通过在完毕方法打印当前的AsyncTask的hashCode来区分是不是同一个AsyncTask,以及时间上的差异来确定是否是并行,得到的结果为:
03-31 13:13:48.505 7050-7050/com.commonproject.debug D/TestAsyncTask: 当前异步任务 : 632327564
03-31 13:13:48.505 7050-7050/com.commonproject.debug D/TestAsyncTask: 当前结束时间 : 2017-03-31 13:13:48
03-31 13:13:48.505 7050-7050/com.commonproject.debug D/TestAsyncTask: 异步任务完毕阶段阶段
03-31 13:13:48.506 7050-7050/com.commonproject.debug D/TestAsyncTask: 当前异步任务 : 496311509
03-31 13:13:48.506 7050-7050/com.commonproject.debug D/TestAsyncTask: 当前结束时间 : 2017-03-31 13:13:48
03-31 13:13:48.507 7050-7050/com.commonproject.debug D/TestAsyncTask: 异步任务完毕阶段阶段
03-31 13:13:48.507 7050-7050/com.commonproject.debug D/TestAsyncTask: 当前异步任务 : 688151786
03-31 13:13:48.507 7050-7050/com.commonproject.debug D/TestAsyncTask: 当前结束时间 : 2017-03-31 13:13:48
03-31 13:13:48.508 7050-7050/com.commonproject.debug D/TestAsyncTask: 异步任务完毕阶段阶段
03-31 13:13:48.508 7050-7050/com.commonproject.debug D/TestAsyncTask: 当前异步任务 : 304548827
03-31 13:13:48.508 7050-7050/com.commonproject.debug D/TestAsyncTask: 当前结束时间 : 2017-03-31 13:13:48由上述结果能够发现,上述的并行的运行过程直接绕过了队列线程池,直接制定运行线程池去运行任务.那么并行的原因在哪呢 ?
public AsyncTask() {
......
try {
//设置线程的优先级
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//运行异步操作
result = doInBackground(mParams);
//将进程中未运行的命令,一并送往CPU处理
Binder.flushPendingCommands();
.........注意Binder.flushPendingCommands()这个JNI命令.
/**
* Flush any Binder commands pending in the current thread to the kernel
* driver. This can be
* useful to call before performing an operation that may block for a long
* time, to ensure that any pending object references have been released
* in order to prevent the process from holding on to objects longer than
* it needs to.
*/
public static final native void flushPendingCommands();这种方法我的理解是将进程中等待的Binder命令,一并提交给CPU处理,当然这会造成一些堵塞,我们知道线程的运行也是依靠CPU来运转,所以我觉得这种方法才是AsyncTask能够同步运行的关键.
在每一个任务运行完时,都会把当前进程的等待任务提交,然后堵塞,等都完毕,该进程内没有Thread提交时,一起返回,从而形成同步.
而在这里之所以不去使用队列线程池的原因也在这,由于队列线程池实现了锁的机制,而且通过它的代码我们能够得知它是处理完一个任务,才会去下个任务,这一块也是AsyncTask默认能够实现串行的原因.
postResult()方法
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
//正常的把结果通过InternalHandler发送给UI线程.
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}这种方法,没有太多可介绍的.熟悉Handler机制的,自然就能看懂.当postResult()方法运行后,InternalHandler
会调用AsyncTask的finish()方法.
finish()方法
private void finish(Result result) {
//推断任务是否被取消,假设被取消则回调onCalled()
if (isCancelled()) {
onCancelled(result);
} else {
//请求成功
onPostExecute(result);
}
//变更AsyncTask的状态
mStatus = Status.FINISHED;
}finish()是返回结果的方法,无论AsyncTask是否被取消都会将该AsyncTask的状态变更成FINISHED.
总结
最后基本上整个AsyncTask的介绍也就清晰了,本文的介绍的思路是:
1.先介绍AsyncTask的核心构成.
2.在介绍AsyncTask的工作流程:
execute() -->executeOnExecutor() -->postResult() --> finish()
3.还了解了AsyncTask中的串行和并行的特点,以及AsyncTask实现并行和串行的原理.AsyncTask内部工作流程图解
这图可能画的有点复杂,事实上细致对比上文的逻辑和源代码看,你一定会弄明确的.而且通读全然文之后,你会发现AsyncTask并不难,原来是这么简单.
參考文章
1.安卓艺术探索