Android中UI的更新主要在主线程中，而耗时操作一般在子线程中进行；我们可以通过handler发送消息的方式处理异步，或是使用Android提供的AsyncTask(还有volley、retrofit等，暂不多说了)。本文主要是从AsyncTask的源码角度去分析其工作原理，来更好地理解android的多线程编程。
AsyncTask是一个抽象的泛型类(泛型指类型不确定)，他主要有3个泛型参数，分别是Params、Progress和Result，其中Params为参数类型，Progress为后台任务执行进度的类型，Result为返回结果的类型。如果不需要某个参数，可以将其设置为Void类型。
1、AsyncTask的使用，先自定义一个类继承AsyncTask，然后创建实例调用execute()执行异步；
myTask.execute();//execute()启动异步，当AsyncTask的参数类型为Void时，参数可以不填
myTask.cancel(true);
...
// 为true时，如果线程执行则会被中断，false时则执行完成;但实际上为true时线程只是调用Interrupt()，
// 在这种情况下并没有中断线程，需要在doInBackground中手动调用if(isCancelled()) return null;
Class MyTask extends AsyncTask<Void,Integer,String >{
String s1,s2;
MyTask(String s1, String s2) {
this.s1 = s1;
this.s2 = s2;
}
/**
* 在主线程中进行，做一些异步之前的准备
*/
@Override
protected void onPreExecute() {
super.onPreExecute();
textView.setText("加载中...");
}
/**
* 在线程池中进行，用来执行耗时操作，返回的类型就是Result的类型
* @param voids 需要传入的参数，此时为Void类型，不需要
* @return
*/
@Override
protected String doInBackground(Void... voids) {
new Thread(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
if (isCancelled()){
return null;
}
}
}).start();
return s1+s2;
}
/**
* 在主线程中
* @param s 该参数为doInBackground中返回的result
*/
@Override
protected void onPostExecute(String s) {
super.onPostExecute(s);
textView.setText(s);
}
/**
*在主线程中,一般用于更新进度条
* @param values 后台任务执行的进度，可以具体打印查看
*/
@Override
protected void onProgressUpdate(Integer... values) {
super.onProgressUpdate(values);
}
/**
*主线程中，在execute()执行异步之后，调用cancel()取消任务,AsyncTask会回调到onCancelled中，同时会跳过onPostExecute()
* @param s
*/
@Override
protected void onCancelled(String s) {
super.onCancelled(s);
}
/**
* 同上，只是没有result参数
*/
@Override
protected void onCancelled() {
super.onCancelled();
}
}
2、以android8.0的AysncTask为例，先看AysncTask的构造函数
public AsyncTask(@Nullable Looper callbackLooper) {
//用户异步任务的消息发送，如果当前looper为空或是默认的looper时调用getMainHandler方法
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
//WorkerRunnable实现了Callable接口
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;
}
};
//FutureTask是一个可管理的异步任务，它实现了Runnable和Future两个接口，提供给Executor执行
//也可以调用线程直接执行(FutureTask.run())
//因此它可以包装Runnable和Future给Executor执行；而WorkRunnable作为参数传递给了FutureTask
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);
}
}
};
}
之后开始执行AysncTask，并调用execute方法，
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
execute方法中又调用了executeOnExecutor方法，
@MainThread
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();//首先调用onPreExecute()
mWorker.mParams = params;//mWorker是之前创建的WorkRunnable，此处用于修改mWorker的mParams
exec.execute(mFuture);
//参数exec为上面传递的sDefaultExecutor，调用execute()传入FutureTask
return this;
}
executeOnExecutor()中传入的sDefaultExecutor是一个串行的线程池，
private static class SerialExecutor implements Executor {
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
//execute()方法的参数是FutureTask
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();//FutureTask.run()
} finally {
//任务执行完时
scheduleNext();
}
}
});
//当前活动没有任务时
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
FutureTask.run()最终会调用WorkRunnable的call()方法,而call方法最后通过postResult()方法将结果抛出
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
在postResult()中创建Message，将结果赋值给这个Message，通过getHandler得到mHandler，并通过mHandler发送消息
private static InternalHandler sHandler;
private final Handler mHandler;
//...
//在WorkRunnable中mHandler初始化时，条件成立时，调用getMainHandler()去创建handler
private static Handler getMainHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler(Looper.getMainLooper());
}
return sHandler;
}
}
//...
//在getMainHandler中创建handler时调用的自定义的handler，
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;
}
}
}
在接收到MESSAGE_POST_RESULT消息后，会调用finish()，如果AsyncTask任务被取消时，则会执行onCancelled()，反之则调用onPostExecute(),通过调用onPostExecute()才能得到异步执行的结果
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
最后回过来分析SerialExecutor,SerialExecutor主要用来处理排队，将任务串行处理，在SerialExecutor中调用scheduleNext()时，将任务提交给THREAD_POOL_EXECUTOR,其实就是threadPoolExecutor,核心线程数是通过CPU的核数计算来的，他的阻塞队列是LinkedBlockQueue，容量为128
// We want at least 2 threads and at most 4 threads in the core pool,
// preferring to have 1 less than the CPU count to avoid saturating
// the CPU with background work
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<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
/**
* An {@link Executor} that can be used to execute tasks in parallel.
*/
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);
threadPoolExecutor.allowCoreThreadTimeOut(true);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}