AsyncTask源码分析

各版本AsyncTask之间的差异

各版本AsyncTask之间的差异主要集中在线程池的使用这一块。主要的分界点有2个，分为3个阶段。第一阶段是3.0以前的版本，第二是3.0-4.4版本的阶段，第三个是4.4版本以后的阶段。那我们一个一个阶段来看。

3.0之前版本中AsyncTask

这里使用2.3版本的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 BlockingQueue<Runnable> sWorkQueue =
            new LinkedBlockingQueue<Runnable>(10);

    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 ThreadPoolExecutor sExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE,
            MAXIMUM_POOL_SIZE, KEEP_ALIVE, TimeUnit.SECONDS, sWorkQueue, sThreadFactory);

在3.0版本以前AsyncTask的线程只有1个线程池，核心线程数为5，最大线程数为128，任务队列容量为10。
也就是说当线程池中的线程数量没到5个，那么有新的任务会直接启动一个核心线程来执行任务，如果线程池中的线程数量达到了5个，然后任务会被插入到任务队列中等待执行，要是任务队列也满了，就会判断线程池中的数量是否已经达到最大线程数128，如果没有达到就会立刻启动一个非核心线程来执行任务。如果线程数量已经达到线程池规定的最大值，那么就会拒绝执行该任务。也就是说该线程池最多能同时接纳138个任务，其中有128个任务可以同时执行。而且该版本只有一个execute(Params... params) 方法，说明不能自定义线程池来执行任务。

3.0-4.4版本中AsyncTask

这里使用4.2版本的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);

    /**
     * An {@link Executor} that can be used to execute tasks in parallel.
     */
    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 volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;
  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);
            }
        }
    }

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

    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;
    }

这个版本的线程池与上个版本并没有什么不同，只是新增加了一个SerialExecutor，从代码中我们可以看到这是一个顺序执行任务的Executor，虽然最后任务还是交给了THREAD_POOL_EXECUTOR来执行，但是使用这个Executor可以保证任务时按先进先出的顺序来执行。同时新增加了executeOnExecutor(Executor exec,Params... params) 方法，这个方法被声明是public的并且接受一个Executor参数，说明我们可以自定义线程池或者使用SerialExecutor来执行任务。如果使用execute（）方法的话，默认会使用SerialExecutor来执行任务。

4.4版本以后AsyncTask

这里使用4.4版本的AsyncTask源代码：

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;

    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>(128);

    /**
     * An {@link Executor} that can be used to execute tasks in parallel.
     */
    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 volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

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);
            }
        }
    }

4.4版本以后的线程池数量改为了动态的，以双核心为例，先获取CPU的核心数为2，线程池的核心线程为3，最大线程数为5,而阻塞队列的容量变为了128。为什么会有这样的改动？可能谷歌公司觉得开启的线程数过多会影响效率吧。而阻塞队列从容量为10变为了128是一个很有意思的事情。在4.4以前的版本，如果已经达到了线程池的核心线程数5，切阻塞队列也达到了10，再有任务加入，就会启动新的非核心线程，也就是说只要同时又16个任务进入就会开启非核心线程。而现在需要132（3+128+1）个任务加入才会开启非核心线程。也就是说要开启新的线程的成本更大了。


 

 

 

 

既然存在handle为什么google还要出AsyncTask（毕竟底层还是用的handle+Executor)  在12年之前那时候还没有一些xtuils、volley的第三方的网络框架，也没有asyncTask的出现，那时候要请求一个网络数据，首先build request参数，然后由于请求网络是耗时操作，所以你得有个Executer或者线程，然后enqueue后，通过线程去run你的请求，得到服务器数据后，callback回调给你的上层。

　 在没有框架的年代，想要做一次请求，是万分痛苦的，你需要自己管理线程切换，需要自己解析读取数据，解析数据成对象，切换回主线程，回调给上层。

　 然后我们的AsyncTask顺势而生了，它不需要我们程序员再手动管理线程，动手写回调之类   

源码结构图：

AsyncTask源码分析

 

 

AsyncTask源码分析

 

AsyncTask的坑：

  •     AsyncTask中维护着一个长度为128的缓冲队列，缓冲队列已满时，如果此时向线程提交任务，将会抛出RejectedExecutionException。

private static final BlockingQueue<Runnable> sPoolWorkQueue =

new LinkedBlockingQueue<Runnable>(128);

  AsyncTask可以分为两个部分说，在3.0以前，最大支持128个线程的并发，外加10个任务的等待在堵塞队列中。在3.0以后，无论有多少任务，都会在其内部单线程执行,AsyncTask 是串行的. 内部使用了futureTask    timer 和 timertask 类似  要想并行 可以使用AsyncTask中的executeOnExecutor 加入自己的线程池来 自定义自己的执行策略； 

  • 生命周期

很多开发者会认为一个在Activity中创建的AsyncTask会随着Activity的销毁而销毁。然而事实并非如此。AsyncTask会一直执行, 直到doInBackground()方法执行完毕。然后，如果 cancel(boolean)被调用, 那么onCancelled(Result result) 方法会被执行；否则，执行onPostExecute(Result result) 方法。如果我们的Activity销毁之前，没有取消 AsyncTask，这有可能让我们的AsyncTask崩溃(crash)。因为它想要处理的view已经不存在了。所以，我们总是必须确保在销毁活动之前取消任务。总之，我们使用AsyncTask需要确保AsyncTask正确地取消。

另外，即使我们正确地调用了cancle() 也未必能真正地取消任务。因为如果在doInBackgroud里有一个不可中断的操作，比如BitmapFactory.decodeStream()，那么这个操作会继续下去。

  • 内存泄漏

如果AsyncTask被声明为Activity的非静态的内部类，那么AsyncTask会保留一个对创建了AsyncTask的Activity的引用。如果Activity已经被销毁，AsyncTask的后台线程还在执行，它将继续在内存里保留这个引用，导致Activity无法被回收，引起内存泄露。在Activity中使用AsyncTask，AsyncTask持有Activity的引用，如果在网络请求没有结束，但是Activity已经被关闭的情况下，Actuvity的引用的不到释放，就会造成内存泄漏。

 

    解决方法:

    1、将AsyncTask设置为static，设置成静态对象后，在Activity类初始化的时候会初始化，会占用一定内存，但是会和Activity同生命周期，Activity销毁时AsyncTask也会被销毁。

    2、使用弱引用WeakReference，这样gc运行时就会回收，避免内存泄漏。

 

    思考：AsyncTask不是有cancel方法吗？在activity生命周期结束前调用cancel方法不就行了吗？为什么不行呢？

最终的interpte 只是发起中断请求 真正取消还是等待合适的时机

  • 不能及时取消任务

以4.4版本双核手机为例，如果用户在A界面发起5个任务，由于使用SerialExecutor来执行任务，那么任务将一个一个顺序执行，由于第一个任务执行时间过长，其他任务只能在队列中等待，导致阻塞，所以可以考虑把执行时间较短的任务优先加入。如果在第一个任务执行过程中，用户跳转到了B界面，而A界面发起的任务已经没有必要执行，所以我们要在Activity的生命周期结束的时候取消掉任务。如果任务没取消掉，B界面又发起新的任务，就会导致B界面的所有请求阻塞。如果有需要我们可以直接使用executeOnExecutor方法，然后直接使用THREAD_POOL_EXECUTOR线程池来执行，这样可以3个线程同时执行，并且在doInBackground方法中判断任务是否被取消，这样可以提高效率。

相关文章：

猜你喜欢
相关资源
相似解决方案
热门标签
Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode