除了传统的 Thread 以外，还包含AsyncTask、HandlerThread以及IntentService,这三者的底层实现也是线程,但是它们具有特殊的表现形式,同时在使用上也各有优缺点。下面讲解使用方法和原理解析
AsyncTask
1.介绍
上文翻译：AsyncTask 是一个被设计为围绕Thread和Handler操作的工具帮助类，而不是作为通用的线程框架，理想情况下，应将AsyncTasks用于短操作（最多几秒钟）。如果需要长时间保持线程运行，Google建议使用java.util.concurrent这个并发包提供的各种API，例如 Executor，ThreadPoolExecutor和 FutureTask。
AsyncTask是一种轻量级的异步任务类，它可以在线程池中执行后台任务，然后把执行的进度和最终结果传递给主线程并在主线程中更新 UI。从实现上来说，AsyncTask 封装了Thread和Handler,通过AsyncTask可以更加方便地执行后台任务以及在主线程中访问UI,但是AsyncTask并不适合进行特别耗时的后台任务,对于特别耗时的任务来说,建议使用线程池。
！This class was deprecated in API level 30.
Use the standard java.util.concurrent or Kotlin concurrency utilities instead.
目前官方已经明确说明，AsyncTask 将会在API 30，也就是Android 11的版本中，将这个类废弃掉。使用java.util.concurrent和Kotlin的协程组件代替AsyncTask 。
2.AsyncTask的参数和重要方法
AsyncTask 是一个抽象的泛型类，它提供了Params、Progress 和 Result这三个泛型参数，其中
- Params表示参数的类型,
- Progress表示后台任务的执行进度的类型
- Result则表示后台任务的返回结果的类型
如果AsyncTask确实不需要传递具体的参数,那么这三个泛型参数可以用Void来代替。AsyncTask这个类的声明如下所示。
//public abstract class AsyncTask<Params, Progress, Result>
// params表示doInBackground方法的参数类型，Progress表示onProgressUpdate方法的参数类型
// result表示doInBackground方法返回值的参数类型，由于doInBackground方法的返回值要传递给onPostExecute 所以onPostExecute方法的参数类型是result
private class DownLoadAsyncTask extends AsyncTask<Integer, Integer, Long>{
定义子类时可重写四大方法：onPreExecute，onProgressUpdate，doInBackground，onPostExecute
-
onPreExecute()
在主线程中执行，这个方法会在后台任务开始执行之前调用，用于进行一些界面上的初始化操作，比如显示一个进度条对话框等。
-
doInBackground(Params…)
在线程池中执行,此方法用于执行后台任务,params参数表示异步任务的输入参数。在此方法中可以通过publishProgress方法来更新任务的进度, publishProgress方法会调用onProgressUpdate方法。另外此方法需要返回计算结果给 onPostExecute 方法。 -
onProgressUpdate(Progress…)
在主线程中执行。当doInBackground(params)调用了publishProgress(Progress…)方法后，此方法中会被调用，传递的参数值就是在后台任务中传递过来的，类型是上面说到的Progress的类型。这个方法是在UI线程操作，对UI进行操作，利用参数中的数值就可以对界面元素进行相应的更新。
onPostExecute(Result)
在主线程中执行，当后台任务执行完毕并通过return语句进行返回时，返回的数据会作为参数传递到此方法中，其中result参数是后台任务的范湖值，即doInback可以利用返回的Result来进行一些UI操作。
上面这几个方法, onPreExecute先执行,接着是doInBackground,最后才是onPostExecute。除了上述四个方法以外, AsyncTask还提供了onCancelled()方法,它同样在主线程中执行**,当异步任务被取消时, onCancelled()方法会被调用**,这个时候onPostExecute则不会被调用。下面提供一个典型的示例,如下所示。
3.使用AsyncTask的限制条件
- 必须在UI线程上加载AsyncTask类。这就意味着第一次访问AsyncTask必须发生在主线程。后面会分析原因。
- 必须在UI线程上创建 AsyncTask子类的实例。
- 必须在UI线程上调用 execute（Params …）。
- 不要手动调用onPreExecute,onPostExecute,doInBackground,onProgressUpdate这几个方法
- 该任务只能执行一次（如果尝试第二次执行，则将引发异常。）
- 在 Android 1.6 之前，AsyncTask 是串行执行任务的，Android 1.6 的时候 AsyncTask开始采用线程池里处理并行任务,但是从Android 3.0开始,为了避免AsyncTask所带来的并发错误， AsyncTask 又采用一个线程来串行执行任务。尽管如此，在 Android 3.0 以及后续的版本中,我们仍然可以通过AsyncTask的executeOnExecutor方法来并行地执行任务。
4.AsyncTask简单使用Demo
package com.example.androidlearn.thread;
import androidx.appcompat.app.AppCompatActivity;
import android.os.AsyncTask;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import com.example.androidlearn.R;
public class AsyncTaskActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_async_task);
findViewById(R.id.btn).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
new DownLoadAsyncTask().execute();
}
});
}
//public abstract class AsyncTask<Params, Progress, Result>
// params表示doInBackground方法的参数类型，Progress表示onProgressUpdate方法的参数类型
// result表示doInBackground方法返回值的参数类型，由于doInBackground方法的返回值要传递给onPostExecute 所以onPostExecute方法的参数类型是result
private class DownLoadAsyncTask extends AsyncTask<Integer, Integer, Long>{
private static final String TAG = "DownLoadAsyncTask";
public DownLoadAsyncTask() {
super();
}
@Override
protected void onPreExecute() {
Log.d(TAG, "onPreExecute: ");
super.onPreExecute();
}
@Override
protected void onPostExecute(Long aLong) {
super.onPostExecute(aLong);
Log.d(TAG, "onPostExecute: "+aLong);
}
@Override
protected void onProgressUpdate(Integer... values) {
Log.d(TAG, "onProgressUpdate: "+values[0]);
super.onProgressUpdate(values);
}
@Override
protected void onCancelled(Long aLong) {
super.onCancelled(aLong);
}
@Override
protected void onCancelled() {
super.onCancelled();
}
@Override
protected Long doInBackground(Integer... integers) {
Log.d(TAG, "doInBackground: ");
int [] arr = new int[]{1, 20, 40 ,60 ,80, 100};
for (int i = 0; i < arr.length; i++) {
onProgressUpdate(arr[i]);
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
return 100l;
}
}
}
模仿下载任务的进度。在 DownloadFilesTask 中，doInBackground用来执行具体的下载任务，每一秒进度增加20，并通过publishProgress方法来更新下载的进度。当下载任务完成后，doInBackground 会返回结果，即100%。需要注意的是，doInBackground是在线程池中执行的。onProgressUpdate用于更新界面中下载的进度,它运行在主线程,当publishProgress被调用时,此方法就会被调用。当下载任务完成后,onPostExecute方法就会被调用,它也是运行在主线程中,这个时候我们就可以在界面上做出一些提示，比如弹出一个对话框告知用户下载已经完成。
Async工作原理
先由一行最简单的启动AsyncTask的代码入手：
new DownLoadAsyncTask ().execute();
进入execute方法查看：
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
}
先看下sDefaultExecutor这个属性是什么名堂：
//sDefaultExecutor 被 volatile修饰
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
//串行执行任务线程池实例
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static class SerialExecutor implements Executor {
//维护一个Runnable的队列
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
//往队尾中压入一个Runnable的同时运行队头的Runnable，维护队列的大小
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
//弹出，执行队头的Runnable
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
//执行 被赋值的mActive 任务
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
//创建核心线程数为 1，最大线程容量为20的线程池，实际的任务执行线程池
public static final Executor THREAD_POOL_EXECUTOR;
static {
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
new SynchronousQueue<Runnable>(), sThreadFactory);
threadPoolExecutor.setRejectedExecutionHandler(sRunOnSerialPolicy);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
可以看到的是sDefaultExecutor，是一个控制任务排队的线程池，被调用execute时会将新的Runnable压入任务队列，如果Runnable mActive == null(第一次的时候)的话会取出队头的Runnable执行，而每当一个任务结束后都会执行任务队列中队头Runnable。
这样做的目的是：保证在不同情况，只能有一个任务可以被执行，SerialExecutor做出了单一线程池的效果。每当一个任务执行完毕后，下一个任务才会得到执行，假如有这么一种情况，主线程快速地启动了很多AsyncTask任务，同一时刻只会有一个线程正在执行，其余的均处于等待状态。
发现AsyncTask中有两个线程池(SerialExecutor和THREAD_POOL_EXECUTOR)和一个Handler (InternalHandler),其中线程池SerialExecutor用于任务的排队,而线程THREAD_POOL_EXECUTOR用于真正地执行任务。
再来看看executeOnExecutor这个方法又有什么名堂：
// Status总共有三种状态
public enum Status {
/**
* 任务还没有执行
*/
PENDING,
/**
* 任务正在执行
*/
RUNNING,
/**
* 任务执行完成
*/
FINISHED,
}
@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;
//由上文提到的 sDefaultExecutor 执行 FutureTask<Result>任务 把这个任务加入队列
exec.execute(mFuture);
return this;
}
//Callable的子类，泛型类型为<Params, Result>
private final WorkerRunnable<Params, Result> mWorker;
private final FutureTask<Result> mFuture;
executeOnExecutor 执行方法，会先检查是否运行了这个任务或者已结束，所以AsyncTask任务规定每个任务只能执行一次，不符合就会抛出异常。接着开始调用 onPreExecute 开始预执行，我们看到了onPreExecute()，这也解释了它确实比doInBackground运行的早，可以做一些准备工作。接下来，用到了我们前面提到的两个对象，这里是把我们传递过去的参数赋给了mWorker的变量，然后看26行 调用了Executor的execute()，并且把mFuture做为参数传递过去了。到这里好像就没了？非也非也，还有很关键的AsyncTask的构造函数👇
/**
* 创建一个新的异步任务。 必须在UI线程上调用此构造函数。
*/
public AsyncTask(@Nullable Looper callbackLooper) {
//获取主线程Looper的Handler对象
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
//Worker线程被运行后会执行异步的任务
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
mTaskInvoked.set(true);
Result result = null;
try {
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
//执行doInBackground(mParams)返回 Result类型
result = doInBackground(mParams);
Binder.flushPendingCommands();
} catch (Throwable tr) {
mCancelled.set(true);
throw tr;
} finally {
postResult(result);
}
return result;
}
};
//FutureTask--泛型参数为 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);
}
}
};
}
//postResultIfNotInvoked 如果未被调用，传递结果
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {
postResult(result);
}
}
//利用Handler将带有result的消息压入消息队列，等待主线程的Handler执行
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
//getHandler()获取到的就是AsyncTask构建对象时创建的‘mHandler’，持有主线程Looper
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
AsyncTask的构造方法，对三个重要的东西（mHandler，mWorker，mFuture）进行了初始化，确保他们在被运行时能够执行相应的任务。
在看一下具体执行任务的代码
//sDefaultExecutor 被 volatile修饰
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
//串行执行任务线程池实例
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
private static class SerialExecutor implements Executor {
//维护一个Runnable的队列
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
//往队尾中压入一个Runnable的同时运行队头的Runnable，维护队列的大小
public synchronized void execute(final Runnable r) {
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();
}
}
});
if (mActive == null) {
scheduleNext();
}
}
//弹出，执行队头的Runnable
protected synchronized void scheduleNext() {
if ((mActive = mTasks.poll()) != null) {
//执行 被赋值的mActive 任务
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
mActive 是runnable对象，THREAD_POOL_EXECUTOR.execute(mActive)执行这个runnable对象的run 方法, runnable对象的run 方法中执行mfuture的run 方法, mfuture就是AsyncTask初始化的futureTask，mfuture的run 方法就运行了mWorker的call()。在call方法中修改线程的优先级，执行熟悉的doInBackground()，结果赋给了result，现在是在另外一个线程里面，所以，在doInBackground方法里面是不能操作UI的。最后返回的时候是调用了postResult()，并把结果当参数传入。
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
// handler发送消息
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
message.sendToTarget();
return result;
}
// 返回mHandler
private Handler getHandler() {
return mHandler;
}
// mHandler在这里被赋值
mHandler = callbackLooper == null || callbackLooper == Looper.getMainLooper()
? getMainHandler()
: new Handler(callbackLooper);
// 调用了getMainHandler 里面有一个 InternalHandler
private static Handler getMainHandler() {
synchronized (AsyncTask.class) {
if (sHandler == null) {
sHandler = new InternalHandler(Looper.getMainLooper());
}
return sHandler;
}
}
这里面就是我们熟悉的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) {
//result.mTask属性是AsyncTask的引用
//当接收到不同类型消息，会分别执行 在UI线程更新进度 和 结束任务的方法
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;
}
}
}
// 看一下publishProgress 这一说明了为什么publishProgress方法会调用onProgressUpdate
protected final void publishProgress(Progress... values) {
if (!isCancelled()) {
getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
new AsyncTaskResult<Progress>(this, values)).sendToTarget();
}
}
private static class AsyncTaskResult<Data> {
final AsyncTask mTask;
final Data[] mData;
AsyncTaskResult(AsyncTask task, Data... data) {
mTask = task;
mData = data;
}
}
由于InternalHandler的实例被创建时，获取的是主线程的Looper，所以它的 handleMessage(msg) 方法自然也是在主线程中执行
再看下这个AsyncTask类内的 finish 方法
private void finish(Result result) {
if (isCancelled()) {
//任务已经被取消了，执行onCancelled
onCancelled(result);
} else {
//任务正常结束了，执行onPostExecute(result)
onPostExecute(result);
}
//将任务状态变更为 已结束
mStatus = Status.FINISHED;
}
判断任务是由于被取消掉而结束还是正常结束，执行onCancelled(result) or 执行onPostExecute(result)
如果你仔细看了，你可能会发现，mFuture实例化的时候，重写的done()方法并没有介绍到，那它在整个流程中处于什么样的作用呢，我们接下来，单独说一下。
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);
}
}
done 方法是在call方法之后被调用。表示异步任务执行完后调用，在Future中，通过get()就可以获取到我们前面说的mWorker中call方法的返回值。那我们再看postResultIfNotInvoked方法，到底对返回的结果做了哪些处理。
private void postResultIfNotInvoked(Result result) {
final boolean wasTaskInvoked = mTaskInvoked.get();
if (!wasTaskInvoked) {
postResult(result);
}
}
我们看到了postResult()，这个方法，我们在上面刚刚讲过，它是在mWorker的call方法中，返回的时候调用的，你可能会问了，这个方法怎么调用了两次，不慌，我们看上面这个方法的名字，就了了解原因了post result if not invoked ，很明显，这处的调用是防止call()里面没有调用而设置的，开关就是的mTaskInvoked，它是一个AtomicBoolean，，我们发现在call方法里面，有这样一段代码
所以，在postResultIfNotInvoked方法里面时，如果执行了call方法，这里就会返回true，下面就无法执行，这样就保证了postResult方法只执行了一次。
源码分析总结
AsyncTask类维护着一个串行执行任务的线程池sDefaultExecutor，一个进程中的所有的 AsyncTask 子类全部在这个线程池中执行。
AysncTask 中的两个线程池（SerialExecutor 和 THREAD_POOL_EXECUTOR）和维护着一个持有主线程Looper的 Handler（InternalHandler），其中线程池 SerialExecutor 保证在不同情况，只能有一个任务可以被执行，THREAD_POOL_EXECUTOR 是核心线程数为1的线程池，负责执行耗时任务，InternalHandler用于将执行环境从后台工作线程切换到主线程，完成UI更新进度，取消任务和任务结束后的UI操作。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
