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

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

    http://blog.csdn.net/chdjj/article/details/39122547

    前言：

    初学AsyncTask时，就想研究下它的实现源码，怎奈源码看了好几遍都没看懂，于是搁置了。最近心血来潮，又看了一些源码，如 HandlerThread，IntentService，AsyncQueryHandler等，收获颇深，于是乎想回头再研究下AsyncTask， 没想到这次居然很容易看懂了。。。
    正文：
    注：1.读者阅读本文前，必须对android的Handler机制以及j.u.c中的线程池有所了解;2.AsyncTask使用方式不再赘述。3.不同版本AsyncTask内容有些不同.

    首先明确AsyncTask是个抽象类，接受三个泛型参数，分表代表任务所需参数类型，任务进度类型，结果类型。
    [java] view plaincopy
    1. public abstract class AsyncTask<Params, Progress, Result>   

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

    其内部有个静态全局的线程池变量THREAD_POOL_EXECUTOR，AsyncTask的doInbackground中的任务就是由此线程池执行。
    [java] view plaincopy
    1. public static final Executor THREAD_POOL_EXECUTOR  
    2.             = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE,  
    3.                     TimeUnit.SECONDS, sPoolWorkQueue, sThreadFactory);  

    ThreadPoolExecutor 各参数含义如下，CORE_POOL_SIZE为核心线程数量，MAXIMUM_POOL_SIZE为线程池最大线程数量，KEEP_ALIVE参数表明 当线程池的线程数量大于核心线程数量，那么空闲时间超过KEEP_ALIVE时，超出部分的线程将被回收,sPoolWorkQueue是任务队列，存储 的是一个个Runnable,sThreadFactory是线程工厂，用于创建线程池中的线程。所有这些参数在AsyncTask内部都已经定义好：
    [java] view plaincopy
    1. private static final int CORE_POOL_SIZE = 5;  
    2.    private static final int MAXIMUM_POOL_SIZE = 128;  
    3.    private static final int KEEP_ALIVE = 1;  
    4.    private static final ThreadFactory sThreadFactory = new ThreadFactory() {  
    5.        private final AtomicInteger mCount = new AtomicInteger(1);  
    6.        public Thread newThread(Runnable r) {  
    7.            return new Thread(r, "AsyncTask #" + mCount.getAndIncrement());  
    8.        }  
    9.    };  
    10.    private static final BlockingQueue<Runnable> sPoolWorkQueue =  
    11.            new LinkedBlockingQueue<Runnable>(10);  

    AsyncTask并不是直接使用上述线程池，而是进行了一层“包装”，这个类就是SerialExecutor,这是个串行的线程池。
    [java] view plaincopy
    1. /** 
    2.      * An {@link Executor} that executes tasks one at a time in serial 
    3.      * order.  This serialization is global to a particular process. 
    4.      */  
    5.     public static final Executor SERIAL_EXECUTOR = new SerialExecutor();  

    看其具体实现：
    [java] view plaincopy
    1. private static class SerialExecutor implements Executor {  
    2.        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();  
    3.        Runnable mActive;  
    4.        public synchronized void execute(final Runnable r) {  
    5.            mTasks.offer(new Runnable() {  
    6.                public void run() {  
    7.                    try {  
    8.                        r.run();  
    9.                    } finally {  
    10.                        scheduleNext();  
    11.                    }  
    12.                }  
    13.            });  
    14.            if (mActive == null) {  
    15.                scheduleNext();  
    16.            }  
    17.        }  
    18.        protected synchronized void scheduleNext() {  
    19.            if ((mActive = mTasks.poll()) != null) {  
    20.                THREAD_POOL_EXECUTOR.execute(mActive);  
    21.            }  
    22.        }  
    23.    }  
    调用execute方法时，先将Runnable包装一下（即加上try-finally块）然后加入队列，接着判断当前mActive是否为 空，第一次调用，此值为空，所以会调用scheduleNext方法，从队列中取出头部的任务，交给线程池THREAD_POOL_EXECUTOR处 理，而处理过程是这样的，先执行原先的Runnable的run方法，接着再执行scheduleNext从队列中取出Runnable，如此循环，直到 队列为空，mActive重新为空为止。我们发现，经过这样的处理，所有任务将串行执行。
    所以我们需要注意，如果两个AsyncTask都调用execute时，如果其中一个AsyncTask任务执行时间非常长，这将导致另一个AsyncTask的任务排队等候，无法执行，因为它们共享同一个线程池且池是串行执行任务的。

    接着看其他成员：
    [java] view plaincopy
    1. private static final int MESSAGE_POST_RESULT = 0x1;//当前消息类型--->任务完成消息  
    2.     private static final int MESSAGE_POST_PROGRESS = 0x2;//当前消息类型-->进度消息  
    3.     private static final InternalHandler sHandler = new InternalHandler();  
    4.     private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;//默认线程池  
    5.     private final WorkerRunnable<Params, Result> mWorker;  
    6.     private final FutureTask<Result> mFuture;  
    7.     private volatile Status mStatus = Status.PENDING;//当前状态  
    8.       
    9.     private final AtomicBoolean mCancelled = new AtomicBoolean();  
    10.     private final AtomicBoolean mTaskInvoked = new AtomicBoolean();  

    sDefaultExecutor指明默认的线程池是串行池,mStatus指明当前任务状态，Status是个枚举类型：
    [java] view plaincopy
    1. public enum Status {  
    2.        /** 
    3.         * Indicates that the task has not been executed yet. 
    4.         */  
    5.        PENDING,//等待执行  
    6.        /** 
    7.         * Indicates that the task is running. 
    8.         */  
    9.        RUNNING,//执行  
    10.        /** 
    11.         * Indicates that {@link AsyncTask#onPostExecute} has finished. 
    12.         */  
    13.        FINISHED,//执行结束  
    14.    }  

    重点看InternalHandler实现：
    [java] view plaincopy
    1. private static class InternalHandler extends Handler {  
    2.        @SuppressWarnings({"unchecked", "RawUseOfParameterizedType"})  
    3.        @Override  
    4.        public void handleMessage(Message msg) {  
    5.            AsyncTaskResult result = (AsyncTaskResult) msg.obj;  
    6.            switch (msg.what) {  
    7.                case MESSAGE_POST_RESULT:  
    8.                    // There is only one result  
    9.                    result.mTask.finish(result.mData[0]);  
    10.                    break;  
    11.                case MESSAGE_POST_PROGRESS:  
    12.                    result.mTask.onProgressUpdate(result.mData);  
    13.                    break;  
    14.            }  
    15.        }  
    16.    }  

    InternalHandler继承自Handler，并复写了handleMessage，该方法根据消息类型做不同处理，如 果任务完成，则调用finish方法，而finish方法根据任务状态（取消or完成）调用onCancelled或者onPostExecute，这两 个是回调方法，通常我们会在onPostExecute中根据任务执行结果更新UI，这也是为什么文档中要求AsyncTask必须在UI线程中创建的原 因，我们的Handler须与UI线程的Looper绑定才能更新UI,并且子线程默认是没有Looper的。
    [java] view plaincopy
    1. private void finish(Result result) {  
    2.        if (isCancelled()) {  
    3.            onCancelled(result);  
    4.        } else {  
    5.            onPostExecute(result);  
    6.        }  
    7.        mStatus = Status.FINISHED;  
    8.    }  
    如果是更新进度的消息(MESSAGE_POST_PROGRESS),那么调用onProgressUpdate方法。

    接下来我们关注的问题是doInbackground方法在何处被调用？联想AsyncTask的使用，当我们创建好一个AsyncTask实例后，我们将调用其execute方法，所以，doInbackground方法应该在execute方法中执行，找到其实现：
    [java] view plaincopy
    1. public final AsyncTask<Params, Progress, Result> execute(Params... params) {  
    2.        return executeOnExecutor(sDefaultExecutor, params);  
    3.    }  

    并没有直接调用doInbackground，而是调用了executeOnExecutor方法:
    [java] view plaincopy
    1. public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,  
    2.            Params... params) {  
    3.        if (mStatus != Status.PENDING) {  
    4.            switch (mStatus) {  
    5.                case RUNNING:  
    6.                    throw new IllegalStateException("Cannot execute task:"  
    7.                            + " the task is already running.");  
    8.                case FINISHED:  
    9.                    throw new IllegalStateException("Cannot execute task:"  
    10.                            + " the task has already been executed "  
    11.                            + "(a task can be executed only once)");  
    12.            }  
    13.        }  
    14.        mStatus = Status.RUNNING;  
    15.        onPreExecute();  
    16.        mWorker.mParams = params;  
    17.        exec.execute(mFuture);  
    18.        return this;  
    19.    }  
    executeOnExecutor方法的作用是使用指定的线程池执行任务，这里当然使用的是sDefaultExecutor,也就是SerialExecutor,但是我们注意到这个方法是公共的，也就是说我们可以手动配置线程池，让AsyncTask并行执行起来，最简单的方法就是使用内部定义好的THREAD_POOL_EXECUTOR。
    executeOnExecutor方法首先检查当前状态，如果不是Pending状态则抛出异常，紧接着修改状态为Running态，接着调用onPreExecute方法(预处理，相信大家不陌生)。
    关键代码是exec.execute(mFuture)这一句，这行代码的作用是执行mFuture中定义好的任务，mFuture为 FutureTask类型，FutureTask是Runnable的实现类（j.u.c中的），所以可以作为线程池execute方法的参数,我们找到 其定义：
    [java] view plaincopy
    1. mFuture = new FutureTask<Result>(mWorker) {  
    2.            @Override  
    3.            protected void done() {  
    4.                try {  
    5.                    postResultIfNotInvoked(get());  
    6.                } catch (InterruptedException e) {  
    7.                    android.util.Log.w(LOG_TAG, e);  
    8.                } catch (ExecutionException e) {  
    9.                    throw new RuntimeException("An error occured while executing doInBackground()",  
    10.                            e.getCause());  
    11.                } catch (CancellationException e) {  
    12.                    postResultIfNotInvoked(null);  
    13.                }  
    14.            }  
    15.        };  

    我们都知道，FutureTask构造时必须传入一个Callable的实现类，线程最终执行的是Callable的call方法(不明白的请看java线程并发库),所以mWorker必然是Callable的实现类:
    [java] view plaincopy
    1. private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {  
    2.       Params[] mParams;  
    3.   }  
    4. Worker = new WorkerRunnable<Params, Result>() {  
    5.           public Result call() throws Exception {  
    6.               mTaskInvoked.set(true);  
    7.               Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);  
    8.               //noinspection unchecked  
    9.               return postResult(doInBackground(mParams));  
    10.           }  
    11.       };  
    最终，我们在WorkRunnable方法中找到了doInBackground方法,历经艰辛啊！！
    剩下最后一个问题：消息是如何发送给Handler的？
    1.任务执行完毕的消息是通过postResult方法发送的：
    [java] view plaincopy
    1. private Result postResult(Result result) {  
    2.        @SuppressWarnings("unchecked")  
    3.        Message message = sHandler.obtainMessage(MESSAGE_POST_RESULT,  
    4.                new AsyncTaskResult<Result>(this, result));  
    5.        message.sendToTarget();  
    6.        return result;  
    7.    }  

    这个AsyncTaskResult封装了数据域和对象本身：
    [java] view plaincopy
    1. private static class AsyncTaskResult<Data> {  
    2.        final AsyncTask mTask;  
    3.        final Data[] mData;  
    4.        AsyncTaskResult(AsyncTask task, Data... data) {  
    5.            mTask = task;  
    6.            mData = data;  
    7.        }  
    8.    }  

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

    [java] view plaincopy
    1. protected final void publishProgress(Progress... values) {  
    2.        if (!isCancelled()) {  
    3.            sHandler.obtainMessage(MESSAGE_POST_PROGRESS,  
    4.                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();  
    5.        }  
    6.    }  


    至此，AsyncTask源码分析完毕！


    稍微做个总结：
    1.AsyncTask是对线程池和Handler的封装，但是默认情况下任务是串行执行的,需注意，多个AsyncTask实例共享同一线程池(线程池是static的)；
    2.高并发任务并不推荐使用AsyncTask，而应该改用线程池；
    3.务必在主线程中创建AsyncTask，因为AsyncTask内部的Handler在创建时必须要绑定主线程的Looper;
    4.只能在doInBackground方法中执行耗时任务，其他方法如onPreExecute、onPostExecute等运行于主线程上.
  • 相关阅读:
    无服务计算应用场景探讨及 FaaS 应用实战
    从零入门 Serverless | Serverless 应用如何管理日志 & 持久化数据
    实验楼流程
    go beego框架与python实现数据交互
    golang 并发运算时主线程先运行完，子线程运行没结束的问题记录
    滑动窗口解决最小子串问题 leetcode3. Longest Substring Without Repeating Characters
    golang 遍历树状结构
    golang 三维向量相关操作
    golang 矩阵乘法、行列式、求逆矩阵
    golang float32/64转string
  • 原文地址：https://www.cnblogs.com/vc60er/p/4670713.html
Copyright © 2020-2023  润新知