【安卓笔记】AsyncTask源码剖析

前言:

初学AsyncTask时,就想研究下它的实现源码,怎奈源码看了好几遍都没看懂,于是搁置了。最近心血来潮,又看了一些源码,如HandlerThread,IntentService,AsyncQueryHandler等,收获颇深,于是乎想回头再研究下AsyncTask,没想到这次居然很容易看懂了。。。

正文:

注:1.读者阅读本文前,必须对android的Handler机制以及j.u.c中的线程池有所了解;2.AsyncTask使用方式不再赘述。3.不同版本AsyncTask内容有些不同.

首先明确AsyncTask是个抽象类,接受三个泛型参数,分表代表任务所需参数类型,任务进度类型,结果类型。

public abstract class AsyncTask<Params, Progress, Result> 

开发者继承AsyncTask后必须重写doInbackground方法,其他方法如onPostExecute等按需重写。

其内部有个静态全局的线程池变量THREAD_POOL_EXECUTOR,AsyncTask的doInbackground中的任务就是由此线程池执行。

public static final Executor THREAD_POOL_EXECUTOR
            = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,
                    TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);

ThreadPoolExecutor各参数含义如下,CORE_POOL_SIZE为核心线程数量,MAXIMUM_POOL_SIZE为线程池最大线程数量,KEEP_ALIVE参数表明当线程池的线程数量大于核心线程数量,那么空闲时间超过KEEP_ALIVE时,超出部分的线程将被回收,sPoolWorkQueue是任务队列,存储的是一个个Runnable,sThreadFactory是线程工厂,用于创建线程池中的线程。所有这些参数在AsyncTask内部都已经定义好:

 private static final int CORE_POOL_SIZE = 5;
    private static final int MAXIMUM_POOL_SIZE = 128;
    private static final int KEEP_ALIVE = 1;
    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());
        }
    };
    private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(10);

AsyncTask并不是直接使用上述线程池,而是进行了一层“包装”,这个类就是SerialExecutor,这是个串行的线程池。

/**
     * An {@link Executor} that executes tasks one at a time in serial
     * order.  This serialization is global to a particular process.
     */
    public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

看其具体实现:

 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 {
                        r.run();
                    } finally {
                        scheduleNext();
                    }
                }
            });
            if (mActive == null) {
                scheduleNext();
            }
        }
        protected synchronized void scheduleNext() {
            if ((mActive = mTasks.poll()) != null) {
                THREAD_POOL_EXECUTOR.execute(mActive);
            }
        }
    }

调用execute方法时,先将Runnable包装一下(即加上try-finally块)然后加入队列,接着判断当前mActive是否为空,第一次调用,此值为空,所以会调用scheduleNext方法,从队列中取出头部的任务,交给线程池THREAD_POOL_EXECUTOR处理,而处理过程是这样的,先执行原先的Runnable的run方法,接着再执行scheduleNext从队列中取出Runnable,如此循环,直到队列为空,mActive重新为空为止。我们发现,经过这样的处理,所有任务将串行执行

所以我们需要注意,如果两个AsyncTask都调用execute时,如果其中一个AsyncTask任务执行时间非常长,这将导致另一个AsyncTask的任务排队等候,无法执行,因为它们共享同一个线程池且池是串行执行任务的。

接着看其他成员:

private static final int MESSAGE_POST_RESULT = 0x1;//当前消息类型--->任务完成消息
    private static final int MESSAGE_POST_PROGRESS = 0x2;//当前消息类型-->进度消息
    private static final InternalHandler sHandler = new InternalHandler();
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;//默认线程池
    private final WorkerRunnable<Params, Result> mWorker;
    private final FutureTask<Result> mFuture;
    private volatile Status mStatus = Status.PENDING;//当前状态

    private final AtomicBoolean mCancelled = new AtomicBoolean();
    private final AtomicBoolean mTaskInvoked = new AtomicBoolean();

sDefaultExecutor指明默认的线程池是串行池,mStatus指明当前任务状态,Status是个枚举类型:

 public enum Status {
        /**
         * Indicates that the task has not been executed yet.
         */
        PENDING,//等待执行
        /**
         * Indicates that the task is running.
         */
        RUNNING,//执行
        /**
         * Indicates that {@link AsyncTask#onPostExecute} has finished.
         */
        FINISHED,//执行结束
    }

重点看InternalHandler实现:

 private static class InternalHandler extends Handler {
        @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;
            }
        }
    }

InternalHandler继承自Handler,并复写了handleMessage,该方法根据消息类型做不同处理,如果任务完成,则调用finish方法,而finish方法根据任务状态(取消or完成)调用onCancelled或者onPostExecute,这两个是回调方法,通常我们会在onPostExecute中根据任务执行结果更新UI,这也是为什么文档中要求AsyncTask必须在UI线程中创建的原因,我们的Handler须与UI线程的Looper绑定才能更新UI,并且子线程默认是没有Looper的。

 private void finish(Result result) {
        if (isCancelled()) {
            onCancelled(result);
        } else {
            onPostExecute(result);
        }
        mStatus = Status.FINISHED;
    }

如果是更新进度的消息(MESSAGE_POST_PROGRESS),那么调用onProgressUpdate方法。

接下来我们关注的问题是doInbackground方法在何处被调用?联想AsyncTask的使用,当我们创建好一个AsyncTask实例后,我们将调用其execute方法,所以,doInbackground方法应该在execute方法中执行,找到其实现:

 public final AsyncTask<Params, Progress, Result> execute(Params... params) {
        return executeOnExecutor(sDefaultExecutor, params);
    }

并没有直接调用doInbackground,而是调用了executeOnExecutor方法:

 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();
        mWorker.mParams = params;
        exec.execute(mFuture);
        return this;
    }

executeOnExecutor方法的作用是使用指定的线程池执行任务,这里当然使用的是sDefaultExecutor,也就是SerialExecutor,但是我们注意到这个方法是公共的,也就是说我们可以手动配置线程池,让AsyncTask并行执行起来,最简单的方法就是使用内部定义好的THREAD_POOL_EXECUTOR。

executeOnExecutor方法首先检查当前状态,如果不是Pending状态则抛出异常,紧接着修改状态为Running态,接着调用onPreExecute方法(预处理,相信大家不陌生)。

关键代码是exec.execute(mFuture)这一句,这行代码的作用是执行mFuture中定义好的任务,mFuture为FutureTask类型,FutureTask是Runnable的实现类(j.u.c中的),所以可以作为线程池execute方法的参数,我们找到其定义:

 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 occured while executing doInBackground()",
                            e.getCause());
                } catch (CancellationException e) {
                    postResultIfNotInvoked(null);
                }
            }
        };

我们都知道,FutureTask构造时必须传入一个Callable的实现类,线程最终执行的是Callable的call方法(不明白的请看java线程并发库),所以mWorker必然是Callable的实现类:

  private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        Params[] mParams;
    }
 mWorker = new WorkerRunnable<Params, Result>() {
            public Result call() throws Exception {
                mTaskInvoked.set(true);
                Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                //noinspection unchecked
                return postResult(doInBackground(mParams));
            }
        };

最终,我们在WorkRunnable方法中找到了doInBackground方法,历经艰辛啊!!

剩下最后一个问题:消息是如何发送给Handler的?

1.任务执行完毕的消息是通过postResult方法发送的:

 private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

这个AsyncTaskResult封装了数据域和对象本身:

 private static class AsyncTaskResult<Data> {
        final AsyncTask mTask;
        final Data[] mData;
        AsyncTaskResult(AsyncTask task, Data... data) {
            mTask = task;
            mData = data;
        }
    }

2.任务进度更新消息是通过publishProgress方法发送的:

 protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            sHandler.obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }

至此,AsyncTask源码分析完毕!

稍微做个总结

1.AsyncTask是对线程池和Handler的封装,但是默认情况下任务是串行执行的,需注意,多个AsyncTask实例共享同一线程池(线程池是static的);

2.高并发任务并不推荐使用AsyncTask,而应该改用线程池;

3.务必在主线程中创建AsyncTask,因为AsyncTask内部的Handler在创建时必须要绑定主线程的Looper;

4.只能在doInBackground方法中执行耗时任务,其他方法如onPreExecute、onPostExecute等运行于主线程上.

时间: 2024-10-13 00:28:40

【安卓笔记】AsyncTask源码剖析的相关文章

[转]【安卓笔记】AsyncTask源码剖析

http://blog.csdn.net/chdjj/article/details/39122547 前言: 初学AsyncTask时,就想研究下它的实现源码,怎奈源码看了好几遍都没看懂,于是搁置了.最近心血来潮,又看了一些源码,如 HandlerThread,IntentService,AsyncQueryHandler等,收获颇深,于是乎想回头再研究下AsyncTask, 没想到这次居然很容易看懂了... 正文: 注:1.读者阅读本文前,必须对android的Handler机制以及j.u.

【安卓笔记】HandlerThread源码剖析

有时候我们需要在应用程序中创建一些常驻的子线程不定期地执行一些计算型任务,这时候可以考虑使用HandlerThread,它具有创建带消息循环的子线程的作用. 一.HanderThread使用示例 先熟悉下HandlerThread的一般用法.我们创建一个如下所示的Activity: package com.example.handlethreaddemo; import android.app.Activity; import android.os.Bundle; import android.

【安卓笔记】IntentService源码剖析

Service组件想必都不陌生,这里不费口舌了.强调一点,Service组件默认运行在UI线程,所以也是会阻塞主线程的,使用时切记不可在Service中执行耗时操作,而应该创建子线程,异步执行. IntentService类封装了在Service中创建子线程的工作(其实创建的是HandlerThread),我们只需继承IntentService,复写其onHandleIntent方法即可,onHandleIntent方法在子线程中运行,该方法的参数Intent来自onStart或者onStart

《STL源码剖析》---stl_pair.h阅读笔记

pair是STL中的模板类型,它可以存储两个元素,它也被称作"对组".在map中已经用到了它,pair其实就是一个struct结构,存有两个public的元素,重载了几个运算符,没有什么成员函数,源代码很简单. G++ 2.91.57,cygnus\cygwin-b20\include\g++\stl_pair.h 完整列表 /* * * Copyright (c) 1994 * Hewlett-Packard Company * * Permission to use, copy,

《STL源码剖析》---stl_tree.h阅读笔记

STL中,关联式容器的内部结构是一颗平衡二叉树,以便获得良好的搜索效率.红黑树是平衡二叉树的一种,它不像AVL树那样要求绝对平衡,降低了对旋转的要求,但是其性能并没有下降很多,它的搜索.插入.删除都能以O(nlogn)时间完成.平衡可以在一次或者两次旋转解决,是"性价比"很高的平衡二叉树. RB-tree(red black tree)红黑树是平衡二叉树.它满足一下规则 (1)每个节点不是红色就是黑色. (2)根节点是黑色. (3)如果节点为红色,则其子节点比为黑色. (4)任何一个节

《STL源码剖析》---stl_iterator.h阅读笔记

STL设计的中心思想是将容器(container)和算法(algorithm)分开,迭代器是容器(container)和算法(algorithm)之间的桥梁. 迭代器可以如下定义:提供一种方法,能够依序寻访某个容器内的所有元素,而又无需暴露该容器的内部表达方式. 在阅读代码之前,要先了解一个新概念:Traits编程技法 template <class T> struct MyIter { typedef T value_type //内嵌型别声明 T *ptr; MyIter(T *p = 0

《python源码剖析》笔记 Python虚拟机框架

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie 1. Python虚拟机会从编译得到的PyCodeObject对象中依次读入每一条字节码指令, 并在当前的上下文环境中执行这条字节码指令. Python虚拟机实际上是在模拟操作中执行文件的过程 PyCodeObject对象中包含了字节码指令以及程序的所有静态信息,但没有包含 程序运行时的动态信息--执行环境(PyFrameObject) 2.Python源码中的PyFrameObject

《python源码剖析》笔记 python虚拟机中的一般表达式

本文为senlie原创,转载请保留此地址:http://blog.csdn.net/zhengsenlie 1.字节码指令 LOAD_CONST:从consts表中读取序号为i的元素并压入到运行时栈中 STORE_NAME:改变local名字空间.从符号表names取序号为i的元素作为变量名, 取运行时栈的栈顶元素作为变量值,完成从变量名到变量值的映射关系的创建. BUILD_MAP:创建一个空的PyDictObject对象,并压入运行时栈 DUP_TOP:将栈顶元素的引用计数增加1,并将它再次

Python源码剖析笔记3-Python执行原理初探

Python源码剖析笔记3-Python执行原理初探 本文简书地址:http://www.jianshu.com/p/03af86845c95 之前写了几篇源码剖析笔记,然而慢慢觉得没有从一个宏观的角度理解python执行原理的话,从底向上分析未免太容易让人疑惑,不如先从宏观上对python执行原理有了一个基本了解,再慢慢探究细节,这样也许会好很多.这也是最近这么久没有更新了笔记了,一直在看源码剖析书籍和源码,希望能够从一个宏观层面理清python执行原理.人说读书从薄读厚,再从厚读薄方是理解了