AndroidAsyncTask源码分析

Posted 寒小枫

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了AndroidAsyncTask源码分析相关的知识,希望对你有一定的参考价值。

android中ui是非线程安全的,更新ui只能在主线程操作,所以我们平时如果遇到子线程更新UI的情况,必须要切换到主线程上之后再执行,Handler消息机制就是一种处理方案,为了更方便的处理异步任务以及更新操作,Android在很早的版本就提供了AsyncTask类供我们处理短耗时的异步任务,方便我们子线程处理耗时任务,主线程更新UI。

AsyncTask其实相当于是Handler和Thread的一个封装,下面我们来看下它的用法吧!

1.AsyncTask的基本使用

我们来看一个简单的例子:

class MyAsyncTask extends AsyncTask<String,Integer,Boolean>

        @Override
        protected void onPreExecute() 
            //在doInBackground之前执行
            Log.e("wangkeke","----onPreExecute      thread: "+ Thread.currentThread().getName());
        

        @Override
        protected Boolean doInBackground(String... strings) 
            Log.e("wangkeke","----doInBackground  thread: "+ Thread.currentThread().getName());

            for (int i = 1; i <= 10; i++) 
                try 
                    Thread.sleep(500);
                    //更新进度
                    publishProgress(i*10);
                 catch (InterruptedException e) 
                    e.printStackTrace();
                
            

            return true;
        

        @Override
        protected void onProgressUpdate(Integer... values) 
            Log.e("wangkeke","----onProgressUpdate当前下载进度:"+values[0]+"   thread: "+ Thread.currentThread().getName());
        

        @Override
        protected void onPostExecute(Boolean aBoolean) 
            Log.e("wangkeke","----onPostExecute任务结束  result = "+aBoolean.booleanValue()+"      thread: "+ Thread.currentThread().getName());

        
    

要使用AsyncTask处理异步任务必须要是继承了它的子类,我们创建了MyAsyncTask类,我们必须重写它的doInBackground方法,当然其他几个方法也很重要一般也要重写,几个关键方法的具体含义如下:
a. onPreExecute:任务开始时会先调用它,它在doInBackground之前执行,用于做一些初始化的工作,它运行在主线程。
b. doInBackground:就像它的名字那样,它用来在子线程中处理耗时操作。
c. onProgressUpdate:用来接收publishProgress()方法传递过来的进度,运行在主线程中。
d. onPostExecute:doInBackground方法执行结束后会调用它,它的参数就是doInBackground的返回值

下面我们来运行一下这个任务:

new MyAsyncTask().execute("start");

嗯,代码很简单,执行AsyncTask的execute方法就可以了,看下运行结果:

我们可以发现AsyncTask类有三个泛型参数,下面介绍一下三个参数的具体含义,AsyncTask<Params, Progress, Result>,Params参数就是execute方法里传递过来的,它的类型是不定长数组,Progress参数代表onProgressUpdate方法的参数类型,Result参数代表onPostExecute方法的参数类型,如果不需要返回类型指定Void即可。

虽然AsyncTask可以用来执行耗时操作,但是官方建议我们最好用于短操作,几秒钟之内的操作,如果是长时间运行的任务,建议使用Executor, ThreadPoolExecutor,FutureTask等。

取消AsyncTask任务:我们可以调用cancel(boolean)方法来取消任务,调用了cancel方法之后,我们可以通过判断isCancel()的返回值是否为true来判断任务取消是否成功,为了尽快取消任务,可以用它来打破for循环。

几个注意点:

1.AsyncTask的类必须在UI线程中加载(android 4.1之后会自动处理),创建和调用。

2.不要主动调用onPreExecute,onPostExecute, doInBackground, onProgressUpdate方法。

3.一个AsyncTask对象只能执行一次execute方法,否则会抛出IllegalStateException异常。

4.AsyncTask在1.6之前是串行执行的,1.6之后允许多个任务并行执行,但3.0之后再次改为串行执行任务(为避免并行执行引发的错误)。

2.AsyncTask串行和并行

测试一下AsyncTask的串行和并行,看看是不是像我们上面说的那样,写个简单的例子,每个任务睡眠2秒后打印当前时间:

    class MyAsyncTask extends AsyncTask<String,Integer,String>

        @Override
        protected void onPreExecute() 
        

        @Override
        protected String doInBackground(String... strings) 

            try 
                Thread.sleep(2000);
             catch (InterruptedException e) 
                e.printStackTrace();
            
            return strings[0];
        

        @Override
        protected void onProgressUpdate(Integer... values) 
        

        @Override
        protected void onPostExecute(String taskName) 
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Log.e("wangkeke",taskName+ "任务结束  时间 = "+df.format(new Date()));
        
    

开启3个任务测试:

new MyAsyncTask().execute("one");
new MyAsyncTask().execute("two");
new MyAsyncTask().execute("three");

我是在Android 4.3系统运行的,运行结果如下,可以看到多任务是串行执行:

本来想启动个1.6-3.0的模拟器试试的,但是很遗憾,没有找到版本这么低的模拟器,因为现在Android版本普遍已经是4.0+了,这里就不测试了,感兴趣的同学可以自己尝试下。

3.AsyncTask源码分析

话不多说,从new MyAsyncTask().execute(“start”)开始:

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

把传入的params和sDefaultExecutor作为参数,调用了executeOnExecutor方法,sDefaultExecutor是什么呢:

//sDefaultExecutor的定义如下
private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

//SERIAL_EXECUTOR的定义如下,注意SerialExecutor对象,下面要用到
public static final Executor SERIAL_EXECUTOR = new SerialExecutor();

sDefaultExecutor其实就是android中的线程池的概念,接着看executeOnExecutor方法:

    @MainThread
    public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,
            Params... params) 
        //开启的AsyncTask任务必须是处于等待执行状态的,如果已经在运行或者已经执行完成,则抛出异常信息
        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)");
            
        
        //开始执行把状态置为RUNNING
        mStatus = Status.RUNNING;
        //之前也说了,onPreExecute会先执行用于一些初始化的操作
        onPreExecute();
        //把参数保存在了mWorker中,mWorker是一个Callable对象
        mWorker.mParams = params;
        //这里调用了Executor的execute方法
        exec.execute(mFuture);
        return this;
    

这段代码也很简单,最后调用了Executor的execute方法,并传递了一个FutureTask,这个exec就是上面的sDefaultExecutor对象,而上面说了它其实就是SerialExecutor对象,看下SerialExecutor的execute方法:

    private static class SerialExecutor implements Executor 
        //队列存储每次的异步任务
        final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
        //当前正在执行的AsyncTask任务
        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);
            
        
    

这里的r就是之前传递过来的FutureTask,看下它的定义:

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

    mWorker = new WorkerRunnable<Params, Result>() 
            public Result call() throws Exception 
                //mTaskInvoked标识任务是否被执行过,这里置为true
                mTaskInvoked.set(true);
                Result result = null;
                try 
                    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
                    //开始调用doInBackground执行异步任务
                    result = doInBackground(mParams);
                    Binder.flushPendingCommands();
                 catch (Throwable tr) 
                    mCancelled.set(true);
                    throw tr;
                 finally 
                    postResult(result);
                
                return result;
            
        ;

上面分析到SerialExecutor的execute方法,内部会调用r.run(),这里的r是futuretask,于是找到futuretask的run方法,发现会执行FutureTask(mWorker)构造函数中mWorker的call方法,mWorker的定义代码在上面列出来了,它调用了doInBackground方法,当futuretask的run方法执行完毕后,会回调自身的done方法。

从上面的代码可以看出done方法中调用了postResultIfNotInvoked,看下它的代码:

    private void postResultIfNotInvoked(Result result) 
        final boolean wasTaskInvoked = mTaskInvoked.get();
        //此时wasTaskInvoked为true,WorkerRunnable中call方法置为true的
        if (!wasTaskInvoked) 
            //发送执行结果
            postResult(result);
        
    

    private Result postResult(Result result) 
        //发送Handler消息
        Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
                new AsyncTaskResult<Result>(this, result));
        message.sendToTarget();
        return result;
    

Handler定义如下:

    private static Handler getMainHandler() 
        synchronized (AsyncTask.class) 
            if (sHandler == null) 
                sHandler = new InternalHandler(Looper.getMainLooper());
            
            return sHandler;
        
    

    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:
                    // 调用自身AsyncTask的finish方法
                    result.mTask.finish(result.mData[0]);
                    break;
                case MESSAGE_POST_PROGRESS:
                    //接收到MESSAGE_POST_PROGRESS消息,更新进度,回调onProgressUpdate方法
                    result.mTask.onProgressUpdate(result.mData);
                    break;
            
        
    

    private void finish(Result result) 
        //如果已经撤销调用onCancelled,否则把结果传递给onPostExecute。
        if (isCancelled()) 
            onCancelled(result);
         else 
            onPostExecute(result);
        
        mStatus = Status.FINISHED;
    

到这里已经执行完毕了,之前doInBackground没有介绍,现在来看下:

@WorkerThread
protected abstract Result doInBackground(Params... params);

它是个抽象方法,需要我们自己去实现,记得我们更新进度的时候,调用了publishProgress方法,来看下它的代码:

    @WorkerThread
    protected final void publishProgress(Progress... values) 
        if (!isCancelled()) 
            getHandler().obtainMessage(MESSAGE_POST_PROGRESS,
                    new AsyncTaskResult<Progress>(this, values)).sendToTarget();
        
    

超级简单,直接用Handler发送了一个MESSAGE_POST_PROGRESS的消息,并且把当前AsyncTask的实例和进度值values传递给handleMessage,handler接收到MESSAGE_POST_PROGRESS消息后开始回调onProgressUpdate:

case MESSAGE_POST_PROGRESS:
      result.mTask.onProgressUpdate(result.mData);
      break;

onProgressUpdate其实是个空方法,我们自己根据业务逻辑实现即可:

    @SuppressWarnings("UnusedDeclaration")
    @MainThread
    protected void onProgressUpdate(Progress... values) 
    

至此,AsyncTask调用逻辑分析完成。

等等,好像有个方法我们还没说,那就是scheduleNext方法:

    protected synchronized void scheduleNext() 
            if ((mActive = mTasks.poll()) != null) 
                THREAD_POOL_EXECUTOR.execute(mActive);
            
        

如果当前没有任务在执行,就调用scheduleNext执行下一个任务,首先通过判断mTasks.poll()方法删除队列中的第一个元素,并把其返回值(它的返回值其实就是当前要执行的task,先移除队列,再执行的意思)赋值给mActive,如果获取到的mActive != null,说明队列中有任务存在,就交由线程池ThreadPoolExecutor去执行。THREAD_POOL_EXECUTOR的定义如下:

    public static final Executor THREAD_POOL_EXECUTOR;

    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;
    

4.AsyncTask如何并行执行?

从上面的分析我们知道,AsyncTask在3.0之后默认是串行的,那么如果我们需要并行执行,该怎么做呢?

其实AsyncTask提供了相关的api,上面我们执行AsyncTask是通过execute方法,它还有另外一个方法executeOnExecutor,就是用来并行执行任务的,下面我们来看下它的基本用法:

    class MyAsyncTask extends AsyncTask<String,Integer,String>

        @Override
        protected void onPreExecute() 
        

        @Override
        protected String doInBackground(String... strings) 

            try 
                Thread.sleep(2000);
             catch (InterruptedException e) 
                e.printStackTrace();
            
            return strings[0];
        

        @Override
        protected void onProgressUpdate(Integer... values) 
        

        @Override
        protected void onPostExecute(String taskName) 
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Log.e("wangkeke",taskName+ "任务结束  时间 = "+df.format(new Date()));
        
    

测试的代码还是上面的代码,我们通过executeOnExecutor开启任务:

new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"one");
new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"two");
new MyAsyncTask().executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"three");

运行结果如下:

可以看到,确实并行执行了任务。

以上是关于AndroidAsyncTask源码分析的主要内容,如果未能解决你的问题,请参考以下文章

集合之LinkedList(含JDK1.8源码分析)

最新Android大厂高频面试题解析大全

最新Android大厂高频面试题解析大全

最新Android大厂高频面试题解析大全

leaflet 结合 d3.js 实现 geojson 数据地形剖面分析(附源码下载)

LinkedList的源码分析