如需转载请评论或简信，并注明出处，未经允许不得转载
目录
前言
多线程在Android开发中非常常见，但是，你还在用这种方式创建一个线程来执行异步任务吗？
new Thread(new Runnable() {
@Override
public void run() {
//TODO 异步操作
}
}).start();
显然，这么做有如下两个比较明显的问题
-
每次
new Thread()都会创建新的Thread对象，性能较差 -
线程缺乏统一管理，可能无限制新建线程，相互之间竞争，甚至可能占用过多的系统资源导致死机或OOM
所以为了写出更高效的程序，我们需要用到线程池（有关线程池的基础知识可以看多线程优化 — 合理使用线程池），Android提供了AsyncTask类，在AsyncTask内部封装了线程池+Handler，避免了很大一部分的性能开销，同时也方便了我们进行多线程开发
AsyncTask的使用
AsyncTask<Params, Progress, Result>是一个泛型类，从命名上可以看出，Params是外部传入的参数（execute(params) -> doInBackground(params) ），Progress是后台线程执行任务的进度（publishProgress(progress) -> onProgressUpdate(progress)），Result是后台线程处理完任务后最后的返回值（doInBackground return result -> onPostExecute(result)）。没有被使用参数用java.lang.Void类型代替
public class UpdateAsyncTask extends AsyncTask<Void, Integer, String> {
private Context context;
public UpdateAsyncTask(Context context) {
this.context = context;
}
/**
* 运行在UI线程中，在调用doInBackground()之前执行
*/
@Override
protected void onPreExecute() {
super.onPreExecute();
Toast.makeText(context, "开始执行", Toast.LENGTH_SHORT).show();
}
/**
* 后台运行的方法，可以运行非UI线程，可以执行耗时的方法
*
* @param voids
* @return
*/
@Override
protected String doInBackground(Void... voids) {
int i = 0;
while (i < 10) {
i++;
publishProgress(i);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return null;
}
/**
* 运行在ui线程中，在doInBackgroung()执行完毕后执行
*
* @param s
*/
@Override
protected void onPostExecute(String s) {
super.onPostExecute(s);
Toast.makeText(context, "执行完毕", Toast.LENGTH_SHORT).show();
}
/**
* 在publishProgress()被调用以后执行，publishProgress()用于更新进度
*
* @param values
*/
@Override
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);
}
}
AsncTask的调用
private void update(){
UpdateAsyncTask asyncTask = new UpdateAsyncTask(this);
asyncTask.execute();
}
使用AysncTask时要注意以下几点：
-
AysncTask的实例必须在主线程中创建 -
AsyncTask的execute方法必须在主线程中调用 - 回调方法，Android会自动调用，不用手动调用
- 一个
AsyncTask的实例，只能执行一次execute() - 若有不同业务，需额外再写一个
AsyncTask子类
AsyncTask源码分析
我们先来点进AsyncTask的execute()看看都做了哪些事情
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
//调用executeOnExecutor(executor,params)
//sDefaultExecutor是Executor对象，稍后分析
return executeOnExecutor(sDefaultExecutor, params);
}
@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
//如果AsyncTask的状态不是PENDING（等待）
//如果是RUNNING（运行中）或者FINISHED（运行结束）就会抛出异常
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)");
}
}
//AsyncTask工作状态标记，Status.RUNNING
mStatus = Status.RUNNING;
//执行onPreExecute()回调
onPreExecute();
//将参数传赋值给mWorker的全局变量
//mWorker是Callable对象，稍后分析
mWorker.mParams = params;
//执行sDefaultExecutor的execute(runnable)
//mFuture是FutureTask对象，稍后分析
exec.execute(mFuture);
return this;
}
AsyncTask执行execute(params)后会先判断工作状态，只有PENDING状态才可以继续执行，之后再把工作状态置为RUNNING。之后将params传入Callable对象mWorker中，再调用线程池sDefaultExecutor的execute(futureTask)开始执行任务
接下来我们分析一下sDefaultExecutor是什么？它是如何被创建和工作的
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
//sDefaultExecutor就是SerialExecutor对象
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
/**
* SerialExecutor是AsyncTask的静态内部类
*/
private static class SerialExecutor implements Executor {
//SerialExecutor 内部维持了1个双向队列
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
// execute()被同步锁synchronized修饰
// 即说明：通过锁使得该队列保证AsyncTask中的任务是串行执行的
// 即 多个任务需1个个加到该队列中；然后 执行完队列头部的再执行下一个，以此类推
public synchronized void execute(final Runnable r) {
//用ArrayDeque将封装后的runnable添加到队尾
//即 向队列中加入一个新的任务
mTasks.offer(new Runnable() {
public void run() {
try {
//执行run方法
r.run();
} finally {
//任务执行完之后，不管有无异常都执行下一个任务
scheduleNext();
}
}
});
// 若当前无任务执行，则执行下一个任务
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
//取出队列头部任务
if ((mActive = mTasks.poll()) != null) {
// 调用THREAD_POOL_EXECUTOR，执行取出的队列头部任务
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
通过上面的分析可以看出，SerialExecutor起到的作用实际上是维护（添加、删除）任务队列，并通过同步锁修饰execute(runnable)从而保证AsyncTask中的任务是串行执行的，而最终真正执行任务的实际上是线程池类THREAD_POOL_EXECUTOR
创建线程池类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() {
//原子类型，为了获取mCount的大小的时候是线程安全的
private final AtomicInteger mCount = new AtomicInteger(1);
public Thread newThread(Runnable r) {
return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());
}
};
//初始化存储任务的队列为LinkedBlockingQueue，用来存放Runnable对象，最大容量为128
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
参数设置完成后，根据参数创建执行任务的线程池THREAD_POOL_EXECUTOR
//根据参数配置执行任务线程池，即 THREAD_POOL_EXECUTOR
public static final Executor THREAD_POOL_EXECUTOR;
static {
//java.util.concurrent.ThreadPoolExecutor类是Executor的实现
//可以配置不同的参数来满足不同的需求
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;
}
扩展：核心线程数和最大线程数有什么区别？（先有一个了解，后续我们会具体分析）
当提交一个新任务到线程池时，首先线程池判断基本线程池(
corePoolSize)是否已满？没满，创建一个工作线程来执行任务。满了，则进入下个流程；其次线程池判断工作队列(
workQueue)是否已满？没满，则将新提交的任务存储在工作队列里。满了，则进入下个流程；
最后线程池判断整个线程池(maximumPoolSize)是否已满？没满，则创建一个新的工作线程来执行任务，满了，则交给饱和策略来处理这个任务；
如果线程池中的线程数量大于corePoolSize时，如果某线程空闲时间超过keepAliveTime，线程将被终止，直至线程池中的线程数目不大于corePoolSize；如果允许为核心池中的线程设置存活时间，那么核心池中的线程空闲时间超过
keepAliveTime，线程也会被终止
接下来我们来分析mWorker和mFuture，这两个变量都是在AsyncTask的构造方法中创建的
public AsyncTask(@Nullable Looper callbackLooper) {
//创建AsyncTask内部的Handler对象
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
//WorkerRunnable是Callable的实现类，作用类似于Runnable
//与Runnable的区别：Callable<T>存在返回值 = 其泛型
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);
Binder.flushPendingCommands();
} catch (Throwable tr) {
//运行异常，设置取消的标识
mCancelled.set(true);
throw tr;
} finally {
//把异步任务的结果发送到主线程，稍后具体分析
postResult(result);
}
return result;
}
};
//FutureTask是Runnable的子类，使用FutureTask类来包装Callable对象
mFuture = new FutureTask<Result>(mWorker) {
//FutureTask内的callable.call()执行完后会调用futureTask的done()
@Override
protected void done() {
try {
//调用FutureTask的get()方法来获得mWorker执行结束后的返回值
//get()方法会阻塞当前线程继续往下执行
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的内部类，实现了Callable
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
private void postResultIfNotInvoked(Result result) {
// 取得任务标记
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {
//若任务未被执行,将未被调用的任务的结果发送到主线程
postResult(result);
}
}
通常情况下我们实现多线程的方式是通过继承Thread或者实现Runnable接口，而这里使用了Callable +FutureTask的方式来实现多线程，这种方式最大的好处就是能够获取任务执行的返回结果
异步任务执行完后，最终会调用postReuslt()。通过代码可以发现，实际上其内部就是通过Handler将消息发送给主线程的。有关Handler机制的详细介绍可以看深入理解Handler机制
private static InternalHandler sHandler;
//asyncTask.postResult
private Result postResult(Result result) {
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
//最终会通过handler发送消息
message.sendToTarget();
return result;
}
/**
* AsyncTask静态内部类，实现了AsyncTask内部的消息处理
*/
private static class InternalHandler extends Handler {
public InternalHandler(Looper looper) {
super(looper);
// 调用时通过Looper.getMainLooper()传入的是主线程的Looper()
// 故AsyncTask的实例创建&execute()必须在主线程使用
}
@Override
public void handleMessage(Message msg) {
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
switch (msg.what) {
// 若收到的消息 = MESSAGE_POST_RESULT
// 则通过finish()将结果通过Handler传递到主线程
case MESSAGE_POST_RESULT:
result.mTask.finish(result.mData[0]);
break;
// 若收到的消息 = MESSAGE_POST_PROGRESS
// 则回调onProgressUpdate()通知主线程更新进度的操作
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
private void finish(Result result) {
// 先判断是否调用了Cancelled()
// 若调用了则执行我们复写的onCancelled()取消任务时的操作
if (isCancelled()) {
onCancelled(result);
} else {
//若无调用Cancelled()，则执行我们复写的onPostExecute(result)
onPostExecute(result);
}
//不管AsyncTask是否被取消，都会将AsyncTask的状态变更为：FINISHED
mStatus = Status.FINISHED;
}
有关AsyncTask的几个问题
AsyncTask到底是串行还是并行
看完我们前面的内容，我们应该能得出AsyncTask的串行的这个结论，包括网上很多文章也都是说AsyncTask在Android 3.0之后就串行执行。但是有没有人很疑惑，既然是串行，为什么还需要用上面这种线程池配置，那有什么意义呢？
实际上，AsyncTask是既可以串行也可以并行的
- 串行
当我们直接调用execute方法的时候，先经过SERIAL_EXECUTOR将任务变成串行执行，再通过THREAD_POOL_EXECUTOR真正执行任务
- 并行
我们可以使用executeOnExecutor方法，并传入THREAD_POOL_EXECUTOR，让请求直接通过线程池执行，这样就是并行执行的
每次创建新的AsyncTask会影响性能吗
根据前面的代码分析我们知道，一个AsyncTask的实例，只能执行一次execute()，若有不同业务，需额外再写一个AsyncTask子类。如果每次都新建一个AsyncTask会影响性能吗？
答案是不会的。因为SERIAL_EXECUTOR和THREAD_POOL_EXECUTOR都是静态变量，他们是类变量，且生命周期和应用生命周期一致，所以每次我们新建的AsyncTask，实际上使用的依然是SERIAL_EXECUTOR和THREAD_POOL_EXECUTOR
为什么AysncTask的实例必须在主线程中创建
因为任务执行完后，会通过AsyncTask内部的InternalHandler把处理结果返回给主线程进行UI操作，而InternalHandler需要依赖主线程的Looper
总结
创建AsyncTask对象时，会在构造方法中创建Callable类型的mWorker和FutureTask类型的mFuture，当外部调用AsyncTask.execute(params)时，会先回调onPreExecute()，之后调用SerialExecutor类的execute(mFuture)，SerialExecutor类维护了任务队列，通过锁保证任务串行执行，最终实际上是调用线程池THREAD_POOL_EXECUTOR.execute(mFuture)去执行具体耗时任务，而mFuture又封装了mWorker，在mWorker的call()方法里，先调用我们复写的doInBackground(mParams)执行耗时操作，再调用postResult(result)， 通过InternalHandler将任务消息传递到主线程，根据消息标识MESSAGE_POST_RESULT判断，最终通过finish()回调我们复写的onPostExecute(result)，从而实现UI更新操作
网友评论