AsyncTask的使用和源码分析

其他 2018-09-16 05:58:47 阅读次数: 0
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/Alexwll/article/details/82049567

1、概述

  • AsyncTask的作用：首先看看API中对AsyncTask的官方解释
<p>AsyncTask enables proper and easy use of the UI thread. This class allows you
 * to perform background operations and publish results on the UI thread without
 * having to manipulate threads and/or handlers.</p>
  1. 上述这句话翻译的意思是：AsyncTask能够正确使用UI线程。允许您在UI线程上执行后台操作和发布结果，而不必操纵线程和/或处理程序
  • AsyncTask的主要方法：
  1. AsyncTask<Params, Progress, Result>: 继承AsyncTask需要传入三个参数类型；Params：后台任务的输入参数类型，Progress：中间进度的数据类型，Result ： 执行结果的数据类型
  2. protected void onPreExecute() ：执行后台任务的准备工作
  3. abstract Result doInBackground(Params... params)：根据参数和逻辑在后台执行操作任务并返回执行的结果，抽象方法必须实现
  4. void onProgressUpdate(Progress... values) ：在操作执行时刷新操作进度，需要配合void publishProgress(Progress... values)方法使用
  5. void onPostExecute(Result result)：返回执行的结果

2、使用

  • 以一个简单例子使用AsyncTask的执行，并输出相应的线程信息，使用方法创建类继承AsyncTask，并重写相应的方法，代码如下：
inner class TestAsyncTask : AsyncTask<Int, Int, String>() {

        override fun doInBackground(vararg params: Int?): String {
            Log.e("method:", "doInBackground()")
            Log.e("Thread:", Thread.currentThread().name)
            val stringBuilder = StringBuilder()
            for (i in params[0]!!..params[0]!! + 10) {   // 输出信息
                stringBuilder.append(i)
                publishProgress(i)   // 更新当前进度
                Thread.sleep(500)
            }
            return stringBuilder.toString()
        }

        override fun onPreExecute() {
            super.onPreExecute()
            Log.e("method:", "onPreExecute()")
            Log.e("Thread:", Thread.currentThread().name)
        }

        override fun onProgressUpdate(vararg i: Int?) {
            super.onProgressUpdate(*i)
            Log.e("method:", "onProgressUpdate()")
            Log.e("Thread:", Thread.currentThread().name)
            Log.e("Progress:", i.toString())
        }
        
        override fun onPostExecute(result: String?) {
            super.onPostExecute(result)
            Log.e("method:", "onPostExecute()")
            Log.e("Thread:", Thread.currentThread().name)
        }
    }
  • 在Activity中的调用
TestAsyncTask().execute(0)
  • 执行结果：

  1. 从上面的执行结果中看出只有DoInBackground（）方法，执行在非UI线程，其余的输出都切换在UI线程，这也就说明l开头的解释：无需开发者对线程管理，AsyncTask会自动切换线程执行任务和输出结果

3、源码分析

相信对于AsyncTask 的使用没什么难度，系统封装好了处理数据和线程的功能，只需按照步骤把要执行的逻辑放进去就好了，现在来看看AsyncTask 是如何处理了复杂逻辑而却给我们提供简单的使用方法，我们知道AsyncTask 的执行是从调用AsyncTask().execute()开始的，一起来看看他的源码吧：

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

@MainThread
    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) {
        if (mStatus != Status.PENDING) {  //判断此时的AsyncTask对象的状态
            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;  //标记AsyncTask对象为运行状态
        onPreExecute();            
        mWorker.mParams = params;  //设置任务参数
        exec.execute(mFuture);
        return this;
    }

从源码中可以看出execute()的方法执行过程：

  1. 从方法注解中看出execute()必须在主线程中调用
  2. 在execute()方法中调用executeOnExecutor（）传入Executor实例和参数params
  3. 在executeOnExecutor（）中，首先判断运行状态，AsyncTask提供三种运行状态：PENDING（未执行）、RUNNING（执行中）、FINISHED（完成）三种状态，只有在PENDING状态下才可执行，且每个对象只能执行一次
  4. 调用onPreExecute()方法初始化数据，此时方法执行在Main线程中
  5. 设置参数，并执行任务

上述所述的执行过程外，方法中还出现了三个变量：sDefaultExecutor 、mWorker、mFuture，从变量的名称和执行的操作我们姑且可以猜测一下,sDefaultExecutor 应该为任务的直接执行者（即线程、线程池）或间接调用线程执行，mWork对执行参数的封装，mFuture是在exec.execute(mFuture)中执行的，所以应该Runnable类的实例，三个对象实现了任务的保存、获取、执行者、如何执行；那如果我们搞懂了这几个类的工作过程也就搞懂了AsyncTask的实现。

3.1  sDefaultExecutor 

  • 查看源码
 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);
            }
        }
    }
  1. sDefaultExecutor是在开始就初始化好的SerialExecutor的实例，sDefaultExecutor最终调用的是SerialExecutor中的execute（）方法
  2. SerialExecutor类中创建一个Runnable队列ArrayDeque<Runnable> Task，用于保存和获取sDefaultExecutor传递的任务
  3. execute（）方法中首先将Runnable添加到对列Task中，在调用mTask.poll()取出头部的Runnable对象
  4. 将拿到的Runnable对象交给THREAD_POOL_EXECUTOR执行，很显然 THREAD_POOL_EXECUTOR为线程池，创建过程如下：
private static final BlockingQueue<Runnable> sPoolWorkQueue =
            new LinkedBlockingQueue<Runnable>(128);   // 任务队列

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

static {
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
                CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,
                sPoolWorkQueue, sThreadFactory);
        threadPoolExecutor.allowCoreThreadTimeOut(true);
        THREAD_POOL_EXECUTOR = threadPoolExecutor;
    }

上述为手动创建线程池的基本过程，还记得前面的Log中执行onBackground（）的线程 AsyncTask #1吗；就是在这个地方创建的，也间接说明了真正执行任务的是线程池

忽略参数细节处理的话，到此Async的执行流程基本出来了，首先调用execute（）方法 --》 判断状态是否为PENDING --》调用prepare准备数据 --》一系列的参数操作 --》在SerialExecutor中的队列中保存任务 -》 取出头部任务 --》 线程池执行取出的任务；。

3.2  mWorker

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);
                Result result = null;
                try {
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    //noinspection unchecked
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                } catch (Throwable tr) {
                    mCancelled.set(true);
                    throw tr;
                } finally {
                    postResult(result);
                }
                return result;
            }
        };
  1. mWork是WorkRunnable的实例，包含保存参数的数组Params，这也验证了我们之前的猜想；
  2. 在AsynTask 的构造函数中创建了mWork，重写了Callable的call（），在方法中调用DoInBackground（）执行任务
  3. 使用mTaskInvoked保存true，此处只是保持一个标志位，作用在下面会看到
  4. 在得到返回结果Result后，通过postResult（）发送数据，postResult（）使用Handler切换线程发送结果，此处的Handler一定在主线程中，详细的Handler后面会介绍
private Result postResult(Result result) {
        @SuppressWarnings("unchecked")
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    }

3.2  mFuture

public class FutureTask<V> implements RunnableFuture<V> {
...
}

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

还记的前面的判断吗？mFuture 为Runnable的对象，在AsyncTask中同样也实例化了mFuture的对象，实现done（）方法，调用 postResultIfNotInvoked（）传递结果：

private void postResultIfNotInvoked(Result result) {
        final boolean wasTaskInvoked = mTaskInvoked.get();
        if (!wasTaskInvoked) {
            postResult(result);
        }
    }
  1. 调用mTaInvoked.get()判断是否已经发送过结果，想起前面mWorker的设置 mTaskInvoked.set(true）了吧，如果没有发送数据，再次调用postResult发送

3.4  线程池执行mFuture

  • 线程池执行后会调用mFuture的run（）方法，源码如下：
public void run() {
        if (state != NEW ||
            !U.compareAndSwapObject(this, RUNNER, null, Thread.currentThread()))
            return;
        try {
            Callable<V> c = callable;
            if (c != null && state == NEW) {
                V result;
                boolean ran;
                try {
                    result = c.call();
                    ran = true;
                } catch (Throwable ex) {
                    result = null;
                    ran = false;
                    setException(ex);
                }
                if (ran)
                    set(result);
            }
        } finally {
            runner = null;
            int s = state;
            if (s >= INTERRUPTING)
                handlePossibleCancellationInterrupt(s);
        }
    }
  1. 首先拿到Callable的实例，提到Callable应该会面熟吧，前面的mWorker就是Callable实例，那mWorker如何传到这的呢？没错前面mFuture传入的mWorker正是此处的mCallabke；
  2. 执行mCallablke的call（），也就是执行mWorker的call（），而mWorker调用了doInbackgroud()和postResult（），到此任务的执行和结果的传递都联系起来了吧
  3. 最后的set（result）会调用mFuture的done（）方法，确认是否传递了参数

到此AsyncTask的参数处理、任务执行和结果的传递都介绍完毕了，相信大家对此过程应该有所了解了，所剩部分就是AsyncTask的线程切换了，前面也提到了是利用Handler实现的，一起看看吧

3.5 线程的切换

  • Handler的实现：定义了过程和结果的传递
 private static class InternalHandler extends Handler {
        public InternalHandler(Looper looper) {
            super(looper);
        }

        @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;
            }
        }
    }
  • Result的传递前面介绍的 postResult（）方法中
  • Progress的传递调用 publishProgress(Progress... values)
protected final void publishProgress(Progress... values) {
        if (!isCancelled()) {
            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        }
    }

好了，大功告成，所有的内容讲完了，有没有感觉代码封装的奇妙之处呢？有没想自己尝试一下写一个简单的AsyncTask呢？心动不如行动，一起实现一个简单的AsyncTask类吧

4、SimpleAsyncTask

代码如下：

/**
 * @author  : Alex
 * @date    : 2018/08/25
 * @version : V 2.0.0
 */
const val PROGRESS = 100
const val RESULT = 101
abstract class SimpleAsyncTask<Params, Progress, Result> {

    val handler = object : Handler(Looper.getMainLooper()) {
        override fun handleMessage(msg: Message?) {
            super.handleMessage(msg)
            when (msg?.what) {
                PROGRESS -> onProgressUpdate(msg.obj as Progress)
                RESULT -> onPostExecute(msg.obj as Result)
            }

        }
    }

    open fun onPreExecute() {

    }

    open abstract fun doInBackground(params: Array<Int>): Result


    open fun onProgressUpdate( progress: Progress) {
    }

    open fun onPostExecute(result: Result) {

    }

    fun postResult(result: Result) {
        val msg = handler.obtainMessage(RESULT, result)
        handler.sendMessage(msg)
    }

    fun publishProgress(progress: Progress) {
        val msg = handler.obtainMessage(PROGRESS, progress)
        handler.sendMessage(msg)
    }

    fun execute(params: Array<Int>) {
        onPreExecute()
        Thread {
            postResult(doInBackground(params))
        }.start()
    }
}

将上面例子中改为继承SimpleAsyncTask，执行结果与AsyncTask执行结果一样：

例子非常简单也体现了执行的过程和逻辑，好了本次到此结束。

猜你喜欢

转载自blog.csdn.net/Alexwll/article/details/82049567
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
周排行
Python环境安装与基础语法（1）——计算机基础知识
IMU预积分
ADAS中的LDW、FCW、BSD、LCA、ACC、AEB、APA、DMS代表的含义
B站笔试两道题
skyeye arm 硬件虚拟机环境的搭建
Web前端静态页面示例
数组-合并排序数组 II-简单
springcloud之版本问题启动报错
面向对象-------------匿名对象(六)
输入URL到页面呈现中间发生了什么？
每日归档
更多
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022