AsyncTask可以正确，轻松地使用UI线程。 此类允许您执行后台操作并在UI线程上发布结果，而无需操纵Threads或者Handler。
AsyncTask被设计为围绕Thread和Handler的帮助类，并不是一个通用的线程框架。 理想情况下，AsyncTasks应该用于短操作（最多几秒钟）。如果您需要长时间保持线程运行，强烈建议您使用java.util.concurrent包提供的各种API。 例如Executor，ThreadPoolExecutor和 FutureTask。
From Google的官方文档
1、AsyncTask的使用
AsyncTask 用来在后台线程中执行任务，当任务执行完毕之后将结果发送到主线程当中。它有三个重要的泛类型参数，分别是 Params、Progress 和 Result，分别用来指定参数、进度和结果的值的类型。 以及四个重要的方法，分别是 onPreExecute(), doInBackground(), onProgressUpdate() 和 onPostExecute()。 这四个方法中，除了 doInBackground()，其他三个都是运行在UI线程的，分别用来处理在任务开始之前、任务进度改变的时候以及任务执行完毕之后的逻辑，而 doInBackground() 运行在后台线程中，用来执行耗时的任务。
1.1、典型的使用：
public class AsyncTaskActivity extends BaseActivity {
private ProgressBar progressBar;
private ImageView imageView;
private TextView textView;
private Button button;
private final String url = "https://upload-images.jianshu.io/upload_images/2177145-33c7b5ff75cf2bf7.png";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_async_task);
imageView = findViewById(R.id.demo_image);
textView = findViewById(R.id.demo_showProgress);
button = findViewById(R.id.demo_button);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View view) {
imageView.setImageBitmap(null);
new MyTask().execute(url);
}
});
}
private class MyTask extends AsyncTask<String, String, Bitmap> {
@Override
protected void onPreExecute() {
super.onPreExecute();
textView.setText("异步开始");
}
@Override
protected Bitmap doInBackground(String... strings) {
publishProgress("正在下载图片");
return getBitmapFromUrl(strings[0]);
}
@Override
protected void onProgressUpdate(String... values) {
super.onProgressUpdate(values);
textView.setText(values[0]);
}
@Override
protected void onPostExecute(Bitmap bitmap) {
super.onPostExecute(bitmap);
imageView.setImageBitmap(bitmap);
textView.setText("下载结束");
}
}
public Bitmap getBitmapFromUrl(String urlString) {
Bitmap bitmap;
InputStream is = null;
try {
URL url = new URL(urlString);
HttpURLConnection connection = (HttpURLConnection) url.openConnection();
is = new BufferedInputStream(connection.getInputStream());
bitmap = BitmapFactory.decodeStream(is);
connection.disconnect();
return bitmap;
} catch (MalformedURLException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return null;
}
1.2、非典型使用(并发)
// 替换1.1中的25 Line，因为只有一个url，此处仅是举例，无实际意义
new MyTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR, url);
使用AsyncTask的时候要注意以下几点内容：
- AsyncTask 的对象必须在主线程中创建；
-
execute()方法必须在UI线程中被调用； - 不要直接调用
onPreExecute(),doInBackground(),onProgressUpdate()和onPostExecute()； - 一个AsyncTask对象的
execute()方法只能被调用一次；
2、AsyncTask源码分析
2.1、AsyncTask 的初始化过程
当初始化一个 AsyncTask 的时候，所有的重载构造方法都会调用下面的这个构造方法。这里做了几件事情：
- 初始化一个 Handler 对象 mHandler，该 Handler 用来将消息发送到它所在的线程中，通常使用默认的值，即主线程的 Handler；
- 初始化一个 WorkerRunnable 对象 mWorker。它是一个
WorkerRunnable类型的实例，而WorkerRunnable又继承自Callable，因此它是一个可以被执行的对象。我们会把在该对象中回调doInBackground()来将我们的业务逻辑放在线程池中执行。 - 初始化一个 FutureTask 对象 mFuture。该对象包装了
mWorker并且当mWorker执行完毕之后会调用它的postResultIfNotInvoked()方法来通知主线程（不论任务已经执行完毕还是被取消了，都会调用这个方法）。
public AsyncTask(@Nullable Looper callbackLooper) {
// 1. 初始化用来发送消息的 Handler
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
// 2. 封装一个对象用来执行我们的任务
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;
}
};
// 3. 初始化一个 FutureTask，并且当它执行完毕的时候，会调用 postResultIfNotInvoked 来将消息的执行结果发送到主线程中
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);
}
}
};
}
当这样设置完毕之后，我们就可以使用 execute() 方法来开始执行任务了。
2.2、AsyncTask 中任务的串行执行过程
我们从 execute() 方法开始分析 AsyncTask，
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
@MainThread
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec, Params... params) {
if (mStatus != Status.PENDING) { // 1.判断线程当前的状态
switch (mStatus) {
case RUNNING: throw new IllegalStateException(...);
case FINISHED: throw new IllegalStateException(...);
}
}
mStatus = Status.RUNNING;
onPreExecute(); // 2.回调生命周期方法
mWorker.mParams = params; // 3.赋值给可执行的对象 WorkerRunnable
exec.execute(mFuture); // 4.在线程池中执行任务
return this;
}
当我们调用 AsyncTask 的 execute() 方法的时候会立即调用它的 executeOnExecutor() 方法。这里传入了两个参数，分别是一个 Executor 和任务的参数 params。从上面我们可以看出，当直接调用 execute() 方法的时候会使用默认的线程池 sDefaultExecutor，而当我们指定了线程池之后，会使用我们指定的线程池来执行任务。
在 1 处，会对 AsyncTask 当前的状态进行判断，这就对应了前面说的，一个任务只能被执行一次。在 2 处会调用 onPreExecute() 方法，如果我们覆写了该方法，那么它就会在这个时候被调用。在 3 处的操作是在为 mWorker 赋值，即把调用 execute 方法时传入的参数赋值给了 mWorker。接下来，会将 mFuture 添加到线程池中执行。
当我们不指定任何线程池的时候使用的 sDefaultExecutor 是一个串行的线程池，它的定义如下：
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
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 {
// 相当于对传入的Runnable进行了一层包装
r.run();
} finally {
// 分配下一个任务
scheduleNext();
}
}
});
// 如果当前没有正在执行的任务，那么就尝试从队列中取出并执行
if (mActive == null) {
scheduleNext();
}
}
protected synchronized void scheduleNext() {
// 从队列中取任务并使用THREAD_POOL_EXECUTOR执行
if ((mActive = mTasks.poll()) != null) {
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
从上面我们可以看出，我们添加到线程池中的任务实际上并没有直接交给线程池来执行，而是对其进行了处理之后才执行的，SerialExecutor 通过内部维护了双端队列ArrayDeque，每当一个 AsyncTask 调用 execute() 方法的时候都会被放在该队列当中进行排队。如果当前没有正在执行的任务，那么就从队列中取一个任务交给 THREAD_POOL_EXECUTOR 执行；当一个任务执行完毕之后又会调用 scheduleNext() 取下一个任务执行。也就是说，实际上 sDefaultExecutor 在这里只是起了一个任务调度的作用，任务最终还是交给 THREAD_POOL_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;
}
2.3、将任务执行的结果发送到其他线程
上面的 WorkerRunnable 中已经用到了 postResult 方法，它用来将任务执行的结果发送给 Handler：
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
Message message = mHandler.obtainMessage(MESSAGE_POST_RESULT, new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
mHandler 会在创建 AsyncTask 的时候初始化。我们可以通过 AsyncTask 的构造方法传入 Handler 和 Looper 来指定该对象所在的线程。当我们没有指定的时候，会使用 AsyncTask 内部的 InternalHandler 创建 Handler：
private final Handler mHandler;
public AsyncTask(@Nullable Looper callbackLooper) {
// 根据传入的参数创建Handler对象
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler() : new Handler(callbackLooper);
}
private static Handler getMainHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
// 使用 InternalHandler 创建对象
sHandler = new InternalHandler(Looper.getMainLooper());
}
return sHandler;
}
}
// AsyncTask 内部定义 的Handler 类型
private static class InternalHandler extends Handler {
public InternalHandler(Looper looper) {
super(looper);
}
@Override public void handleMessage(Message msg) {
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
// 根据传入的消息类型进行处理
switch (msg.what) {
case MESSAGE_POST_RESULT: result.mTask.finish(result.mData[0]); break;
case MESSAGE_POST_PROGRESS: result.mTask.onProgressUpdate(result.mData); break;
}
}
}
3、总结
上面我们梳理了 AsyncTask 的大致过程，我们来梳理下：
创建 AsyncTask是会创建mWorker和mFuture，mFuture是一个Runable类型的对象，最终会在我们执行execute ---> executeOnExecutor时，先调用了onPreExecute()方法，然后将mFuture传入执行队列中等待执行。这里存在两个线程池，一个是 SerialExecutor，一个是 THREAD_POOL_EXECUTOR，前者主要用来进行任务调度，即把交给线程的任务放在队列中进行排队执行，而实际上所有的任务都是在后者中执行完成的。在mFuture被执行的时候，会回调mWorker的call方法，call方法里会调用doInBackground方法，获得doInBackground的执行结果后调用postResult方法，postResult内部通过handler切换线程，最终调用我们的finish方法，finish里面会调用onCancelled(result)或者onPostExecute(result);中的一个。这样我们的AsyncTask的一个关键流程就走完了。
