Android
AsyncTask
Java Doc API 27:
AsyncTask即Asynchronous Task，异步任务。AsyncTask能更好地利用UI线程，可以运行后台操作然后在UI线程上展示结果，无需创建一堆线程或者Handler。
AsyncTask最好用于短时间操作，不超过数秒钟。如果要长时间保持线程运行一个操作的话，最好使用java.util.concurrent包下面的API，比如Executor，ThreadPoolExecutor，FutureTask。
主要分为三种类型，Params，Progress和Result，即传入的三种泛型。以及四个步骤，onPreExecute，doInBackground，onProgressUpdate和onPostExecute，要注意的是拿来定义泛型的需要是包装类型，比如Integer
AsyncTask是个抽象类，所以必须继承使用（此外如果用做内部类要注意内存泄漏），必须重写doInBackground
使用方法很简单：new MyAsyncTask().execute(.., .., ..)即可
三种泛型：Params，用于传给任务执行的参数
Progress，后台运算过程中打印出来的过程单位
Result，后台运算结果
如果哪种泛型用不上，标注为Void即可，比如
public class MyAsyncTask extends AsyncTask<Void, Void, Void> {}
四个步骤：
onPreExecute(): 在任务被执行之前，在UI线程调用，用于设置任务，比如显示一个Progress Bar
doInBackground(): 在onPreExecute执行完后立刻在后台线程执行，可以把参数传到这里，调用publishProgress可以把参数传到onProgressUpdate以便在UI线程执行
onProgressUpdate(): 同上，可以以任何形式展示当前进度，比如展示进度条或者打log
onPostExecute(): 后台计算完成后在UI线程调用，结果会作为参数（在doInBackground中以return形式）传过来
取消任务
调用cancel(boolean)即可，之后isCancelled()会返回true，onCancelled(Object)会被调用，可以在doInBackground里面不断检查isCancelled()的返回值
线程使用规则：
- AsyncTask必须在UI线程创建
- 必须在UI线程加载（API16之后这事会自动完成）
- execute()方法必须在UI线程执行
- 不要主动调用里面的四个步骤方法
- 任务只能执行一次
内存观测：
这点没太看懂，应该是指onPreExecute中和构造中定义的变量，在doInBackground中指向不会受到同步的影响，同理doInBackground中设置和onPostExecute中指向也不会。
执行顺序：
原先默认能同时执行多个任务，现在想要执行多个任务需要传入自定义的Executor
public abstract class AsyncTask<Params, Progress, Result> {
...
private static InternalHandler sHandler;
private final Handler mHandler;
...
/**
* Creates a new asynchronous task. This constructor must be invoked on the UI thread.
*/
public AsyncTask() {
this((Looper) null);
}
/**
* @hide
*/
public AsyncTask(@Nullable Handler handler) {
this(handler != null ? handler.getLooper() : null);
}
/**
* @hide
*/
public AsyncTask(@Nullable Looper callbackLooper) {
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
...
}
}
从这里就能看出来，它是只能继承使用的，而三个定义在这里的泛型名称分别是用于三个步骤方法的。
而两个Handler，mHandler和sHandler其实都是同一个，因为第二个构造方法被标注为hide了，要使用Looper就只能为空，所以注释里一直在强调一定运行在UI线程中，不在UI线程的话，先不说Handler创建时可能抛Exception，最后处理消息时也发不回UI线程来。
关于InternalHandler
private void finish(Result result) {
if (isCancelled()) {
onCancelled(result);
} else {
onPostExecute(result);
}
mStatus = Status.FINISHED;
}
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;
}
}
}
消息类型两种，Result和Progress，可以看出来onProgressUpdate, onPostExecute和onCancelled都是从这里收到消息，在主线程处理的。
发消息的地方：
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
@WorkerThread
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
其中，publishProgress是主动调用的，postResult则在WorkerRunnable和FutureTask中
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
Result result = null;
try {
result = doInBackground(mParams);
} finally {
postResult(result);
}
return result;
}
};
mFuture = new FutureTask<Result>(mWorker) {
@Override
protected void done() {
try {
postResultIfNotInvoked(get());
} catch (CancellationException e) {
postResultIfNotInvoked(null);
}
}
};
里面多余的代码被去掉了，执行时也就是
@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
Params... params) {
if (mStatus != Status.PENDING) {
switch (mStatus) {
case RUNNING:
throw new IllegalStateException("...");
case FINISHED:
throw new IllegalStateException("...");
}
}
mStatus = Status.RUNNING;
onPreExecute();
mWorker.mParams = params;
exec.execute(mFuture);
return this;
}
在正式执行futureTask之前，onPreExecute会被调用，而刚开始会判断状态，代表这个task不能再运行第二次。
尝试写一个AsyncTask
public class AsyncTaskTest extends AsyncTask<List, Integer, Integer> {
private final static String TAG_ASYNC_TASK = "tag_async_task";
@Override
protected Integer doInBackground(List... lists) {
if (null == lists || lists.length == 0) {
return 0;
}
ArrayList<List> testLists = new ArrayList<>();
for (List testList : lists) {
for (int i = 0; i < (int) (Math.random() * 100); i++) {
testList.add(i);
}
testLists.add(testList);
}
int sortedCount = 0;
for (List currList : testLists) {
Collections.sort(currList);
publishProgress(sortedCount);
sortedCount++;
}
return sortedCount;
}
@Override
protected void onProgressUpdate(Integer... values) {
Log.d(TAG_ASYNC_TASK, values[0] + "");
}
@Override
protected void onPostExecute(Integer integer) {
Log.d(TAG_ASYNC_TASK, integer + "");
}
}
