版权声明:本文为博主原创文章,未经博主允许不得转载。
本文纯个人学习笔记,由于水平有限,难免有所出错,有发现的可以交流一下。
一、AsyncTask 使用
在Android 开发中,我们经常使用 Handler 与子线程进行配合,子线程通过 Handler 发送 Message 到主线程,主线程接收到 Message 后,对 UI 进行相应的更新,从而实现子线程更新 UI 操作。
AsyncTask 是一个辅助类,其实就是对 Thread 和 Handler 进行一个封装,方便我们在后台线程中执行一些操作,然后主线程根据返回的结果进行 UI 更新。我们无需关注 Thread 和 Handler 是如何进行工作的,只需要处理好自己的业务逻辑即可。
1.AsyncTask 的使用
AsyncTask 是一个抽象类,使用时候需要进行继承,
AsyncTask 三个参数:
Params 是指调用 execute() 方法时传入的参数类型和 doInBackgound() 的参数类型
Progress 是指更新进度时传递的参数类型,即 publishProgress() 和 onProgressUpdate() 的参数类型
Result 是指 doInBackground() 的返回值类型
AsyncTask 主要方法:
public class MyTask extends AsyncTask<Void, Integer, Integer>{
/**
* 在 UI 线程中运行,
* 调用 doInBackground()之前执行
*/
@Override
protected void onPreExecute() {
}
/**
* 后台运行,主要的逻辑处理
*/
@Override
protected Integer doInBackground(Void... params) {
//更新进度,给 onProgressUpdate 传递进度参数
publishProgress(0);
return null;
}
/**
* 在 UI 线程中运行,
* 在 doInBackground() 执行完毕后执行
*/
@Override
protected void onPostExecute(Integer integer) {
}
/**
* 在 publishProgress() 被调用以后执行,
* publishProgress() 用于更新进度
*/
@Override
protected void onProgressUpdate(Integer... values) {
}
2.多个 AsyncTask 串行运行
对于同一个 AsyncTask 类,有多个实例的话,他们的运行顺序是串行的,需要等待前一个任务执行完毕才会执行后一个任务。
onCreate:
private static long start;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
MyTask myTask = new MyTask();
MyTask myTask1 = new MyTask();
start = System.currentTimeMillis();
myTask.execute();
myTask1.execute();
}
在 doInBackground 中添加 sleep 即可。
doInBackground:
protected Integer doInBackground(Void... params) {
publishProgress(0);
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Log.e("MyTask", "111 zx run time:" + (System.currentTimeMillis()-start) );
return null;
}
结果:
注:顺便提一下,Timer 也是串行运行的。
具体原因在下方源码分析中给出。
二、AsyncTask 源码分析
AsyncTask 是直接进行 new 出来的,我们先查看其构造函数。
AsyncTask 构造函数:
public AsyncTask() {
this((Looper) null);
}
public AsyncTask(@Nullable Handler handler) {
this(handler != null ? handler.getLooper() : null);
}
public AsyncTask(@Nullable Looper callbackLooper) {
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
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<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);
}
}
};
}
在这里面出现两个类,WorkerRunnable 和 FutureTask,我们先分析这两个类,都比较简单。
1.WorkerRunnable
WorkerRunnable 是一个实现了 Callable 接口的抽象类,Callable 有一个 call 方法接口。
WorkerRunnable:
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
Params[] mParams;
}
Callable:
public interface Callable<V> {
/**
* Computes a result, or throws an exception if unable to do so.
*
* @return computed result
* @throws Exception if unable to compute a result
*/
V call() throws Exception;
}
2.FutureTask
**作用:**FutureTask 会先执行 WorkerRunnable 中的 call 方法,执行完毕之后,调用 done 方法进行回调。
FutureTask 实现了接口 RunnableFuture,接口 RunnableFuture 继承 Runnable 和 Future,其实,本质上就是 FutureTask 实现了对 Runnable 的一个封装。我们查看 FutureTask 的 run 方法。
* FutureTask 的 run:*
public void run() {
if (state != NEW ||
!U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
return;
try {
Callable<V> c = callable;
if (c != null && state == NEW) {
V result;
boolean ran;
try {
//调用 WorkerRunnable 的 call 方法。
result = c.call();
ran = true;
} catch (Throwable ex) {
result = null;
ran = false;
setException(ex);
}
if (ran)
//会调到自身的 done 方法,该方法被重写
set(result);
}
} finally {
// runner must be non-null until state is settled to
// prevent concurrent calls to run()
runner = null;
// state must be re-read after nulling runner to prevent
// leaked interrupts
int s = state;
if (s >= INTERRUPTING)
handlePossibleCancellationInterrupt(s);
}
}
FutureTask 的 run 中会调用到 WorkerRunnable 的 call 方法,WorkerRunnable 是在初始化时候传递进来的,执行完毕之后,调用到自身方法 set(result),set 调用到 finishCompletion 方法,finishCompletion 方法会调用到 done ,这个方法在实现的时候被重写,从而实现回调。
set 和 finishCompletion 方法:
protected void set(V v) {
if (U.compareAndSwapInt(this, STATE, NEW, COMPLETING)) {
outcome = v;
U.putOrderedInt(this, STATE, NORMAL); // final state
finishCompletion();
}
}
private void finishCompletion() {
// assert state > COMPLETING;
for (WaitNode q; (q = waiters) != null;) {
if (U.compareAndSwapObject(this, WAITERS, q, null)) {
for (;;) {
Thread t = q.thread;
if (t != null) {
q.thread = null;
LockSupport.unpark(t);
}
WaitNode next = q.next;
if (next == null)
break;
q.next = null; // unlink to help gc
q = next;
}
break;
}
}
done();
callable = null; // to reduce footprint
}
3.AsyncTask
AsyncTask 的执行是通过调用 execute 方法开始的,我们从 execute 方法开始分析。
AsyncTask 的 execute:
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
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 调用了 executeOnExecutor 方法,先执行了 onPreExecute 方法,然后在通过 exec (即 sDefaultExecutor )进行执行 mFuture。这是 onPreExecute 在 doInBackground 之前执行的原因。
sDefaultExecutor 中包含一个 AsyncTask 实现的内部线程池 THREAD_POOL_EXECUTOR,通过这个线程池进行运行 AsyncTask ,代码也相对比较简单。
不过要注意的是,在 SerialExecutor 中,调用 execute 方法,只是把 Runnable 添加到任务队列中进行排队,而不是马上执行,只有当一个 Runnable 执行完毕之后,才会继续执行后一个 Runnable。由于 sDefaultExecutor 在 AsyncTask 中是静态的,所以对于同一个 AsyncTask,如果有多个实例,他们的执行是串行的。
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);
}
}
}
在 SerialExecutor 中通过线程池执行了 Runnable 的 run 方法,这个 Runnable 就是上面 executeOnExecutor 传递进来的全局变量 mFuture。这个是在构造函数中进行初始化。
AsyncTask 构造函数:
public AsyncTask() {
this((Looper) null);
}
public AsyncTask(@Nullable Handler handler) {
this(handler != null ? handler.getLooper() : null);
}
public AsyncTask(@Nullable Looper callbackLooper) {
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
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<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);
}
}
};
}
我们前面分析过,执行 mFuture,会先执行 mWorker 的 call 方法,当执行完毕后,会回调 mFuture 的 done 方法。在 mWorker 的 call 中调用到了 doInBackground 方法。执行完毕之后,mFuture 的 done 方法调用了 postResultIfNotInvoked。
AsyncTask 的 postResultIfNotInvoked:
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {
postResult(result);
}
}
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
postResultIfNotInvoked 调用了 postResult 方法,在 postResult 中,通过 Handler 发送消息 MESSAGE_POST_RESULT。
getHandler 获取的 mHandler 是在构造函数中初始化的。
AsyncTask 的 getHandler:
private Handler getHandler() {
return mHandler;
}
mHandler 在初始化的时候,是通过 getMainHandler 进行初始化的 InternalHandler。
AsyncTask 的 getMainHandler:
private static Handler getMainHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler(Looper.getMainLooper());
}
return sHandler;
}
}
我们进行查看 InternalHandler 代码,查看消息 MESSAGE_POST_RESULT,直接调用的是 AsyncTask 的 finish 方法。
AsyncTask 的 InternalHandler :
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;
}
}
}
继续查看 AsyncTask 的 finish 方法,如果不是取消的话,进行调用 onPostExecute 进行回调。这是 onPostExecute 在 doInBackground 执行完毕之后执行的原因。
AsyncTask 的 finish:
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
流程至此结束。
三、AsyncTask 并行运行
有时候由于需求的原因,我们要求多个 AsyncTask 任务并行执行。可以直接使用 AsyncTask 的 executeOnExecutor 方法,这个方法需要传递一个线程池下去,只要线程池中没有排队这个逻辑,就可以并行运行。
我们前面分析可以发现,AsyncTask 中有一个自带的线程池 THREAD_POOL_EXECUTOR,可以直接使用这个即可。
onCreate:
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
MyTask myTask = new MyTask();
MyTask myTask1 = new MyTask();
start = System.currentTimeMillis();
myTask.executeOnExecutor(MyTask.THREAD_POOL_EXECUTOR);
myTask1.executeOnExecutor(MyTask.THREAD_POOL_EXECUTOR);
}
结果:
当然,也可以使用自己实现的线程池进行任务的执行。