【Android -- 多线程】AsyncTask

不断学习，做更好的自己！💪

视频号	CSDN	简书
欢迎打开微信，关注我的视频号：程序员朵朵	点我	点我

简介

AsyncTask 直接继承于 Object 类，位置为 android.os.AsyncTask。
首先明确 Android 之所以有 Handler 和 AsyncTask ，都是为了不阻塞主线程（UI线程），且 UI 的更新只能在主线程中完成，因此异步处理是不可避免的。Android 的 AsyncTask 比 Handler 更轻量级一些，适用于简单的异步处理。

原理

AsyncTask 是 Android 提供的轻量级的异步类,可以直接继承 AsyncTask,在类中实现异步操作,并提供接口反馈当前异步执行的程度(可以通过接口实现UI进度更新),最后反馈执行的结果给 UI 主线程.

特点

优点:

• 简单,快捷

• 过程可控

缺点:

• 在使用多个异步操作和并需要进行 UI 变更时,就变得复杂起来.

使用

参数

AsyncTask 定义了三种泛型参数：

• Params
  启动任务执行的输入参数，比如HTTP请求的URL。
• Progress
  后台任务执行的百分比。
• Result
  后台执行任务最终返回的结果，比如String。

方法

1. 最少重载如下两个方法：

• doInBackground(Params…)
  后台执行，比较耗时的操作都可以放在这里。
  注意：这里不能直接操作 UI。此方法在后台线程执行，完成任务的主要工作，通常需要较长的时间。在执行过程中可以调用 publicProgress(Progress…) 来更新任务的进度。
• onPostExecute(Result)
  相当于Handler 处理UI的方式，在这里面可以使用在doInBackground 得到的结果处理操作UI。 此方法在主线程执行，任务执行的结果作为此方法的参数返回。

2. 有必要的话，重载如下三个方法：
   onProgressUpdate(Progress…)
   可以使用进度条增加用户体验度。 此方法在主线程执行，用于显示任务执行的进度。
   onPreExecute()
   这里是最终用户调用Excute时的接口，当任务执行之前开始调用此方法，可以在这里显示进度对话框。
   onCancelled()
   用户调用取消时，要做的操作。

使用准则

• AsyncTask 的实例必须在 UI 线程中创建；
• execute 方法必须在 UI 线程中调用；
• 不要直接调用 onPreExecute(), onPostExecute(Result)，doInBackground(Params…), onProgressUpdate(Progress…) 方法；
• 一个AsyncTask对象只能执行一次，即只能调用一次execute方法，否则会报运行时异常

源码分析

public abstract class AsyncTask<Params, Progress, Result> {
   
    private static final String LOG_TAG = "AsyncTask";
 
	//获取当前的cpu核心数
    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
	//线程池核心容量
    private static final int CORE_POOL_SIZE = CPU_COUNT + 1;
	//线程池最大容量
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
	//过剩的空闲线程的存活时间
    private static final int KEEP_ALIVE = 1;
	//ThreadFactory 线程工厂，通过工厂方法newThread来获取新线程
    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());
        }
    };
	//静态阻塞式队列，用来存放待执行的任务，初始容量：128个
    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);
 
    /**
     * 静态并发线程池，可以用来并行执行任务，尽管从3.0开始，AsyncTask默认是串行执行任务
	 * 但是我们仍然能构造出并行的AsyncTask
     */
    public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);
 
    /**
     * 静态串行任务执行器，其内部实现了串行控制，
	 * 循环的取出一个个任务交给上述的并发线程池去执行
     */
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
	//消息类型：发送结果
    private static final int MESSAGE_POST_RESULT = 0x1;
	//消息类型：更新进度
    private static final int MESSAGE_POST_PROGRESS = 0x2;
	/**静态Handler，用来发送上述两种通知，采用UI线程的Looper来处理消息
	 * 这就是为什么AsyncTask必须在UI线程调用，因为子线程
	 * 默认没有Looper无法创建下面的Handler，程序会直接Crash
	 */
    private static final InternalHandler sHandler = new InternalHandler();
	//默认任务执行器，被赋值为串行任务执行器，就是它，AsyncTask变成串行的了
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
	//如下两个变量我们先不要深究，不影响我们对整体逻辑的理解
    private final WorkerRunnable<Params, Result> mWorker;
    private final FutureTask<Result> mFuture;
	//任务的状态 默认为挂起，即等待执行，其类型标识为易变的（volatile）
    private volatile Status mStatus = Status.PENDING;
    //原子布尔型，支持高并发访问，标识任务是否被取消
    private final AtomicBoolean mCancelled = new AtomicBoolean();
	//原子布尔型，支持高并发访问，标识任务是否被执行过
    private final AtomicBoolean mTaskInvoked = new AtomicBoolean();
 
	/*串行执行器的实现，我们要好好看看，它是怎么把并行转为串行的
	 *目前我们需要知道，asyncTask.execute(Params ...)实际上会调用
	 *SerialExecutor的execute方法，这一点后面再说明。也就是说：当你的asyncTask执行的时候，
	 *首先你的task会被加入到任务队列，然后排队，一个个执行
	 */
    private static class SerialExecutor implements Executor {
   
		//线性双向队列，用来存储所有的AsyncTask任务
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
		//当前正在执行的AsyncTask任务
        Runnable mActive;
 
        public synchronized void execute(final Runnable r) {
   
			//将新的AsyncTask任务加入到双向队列中
            mTasks.offer(new Runnable() {
   
                public void run() {
   
                    try {
   
						//执行AsyncTask任务
                        r.run();
                    } finally {
   
						//当前AsyncTask任务执行完毕后，进行下一轮执行，如果还有未执行任务的话
						//这一点很明显体现了AsyncTask是串行执行任务的，总是一个任务执行完毕才会执行下一个任务
                        scheduleNext();
                    }
                }
            });
			//如果当前没有任务在执行，直接进入执行逻辑
            if (mAc