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()的返回值
线程使用规则：

1. AsyncTask必须在UI线程创建
2. 必须在UI线程加载（API16之后这事会自动完成）
3. execute()方法必须在UI线程执行
4. 不要主动调用里面的四个步骤方法
5. 任务只能执行一次
   内存观测：
   这点没太看懂，应该是指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 + "");
    }
}