【Android -- 多线程】AsyncTask

Kevin-Dev

已于 2022-05-27 15:21:49 修改

阅读量2.8k

点赞数

CC 4.0 BY-SA版权

分类专栏： Android -- 线程 & 进程文章标签： android 多线程 AsyncTask

于 2017-05-02 17:27:40 首次发布

本文为博主原创文章，未经博主允许不得转载。

本文链接：https://blog.youkuaiyun.com/duoduo_11011/article/details/71084765

本文介绍了Android中的AsyncTask，它是轻量级的异步处理类，用于在后台执行任务并更新UI。文章详细讲解了AsyncTask的原理、特点、使用方法及参数，包括doInBackground和onPostExecute等关键方法，并提供了源码分析和实例应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

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

简介

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。

方法

最少重载如下两个方法：

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

有必要的话，重载如下三个方法：
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 (mActive == null) {
   
   
                schedul