从源码的角度了解AsyncTask

古城微笑少年丶 2022-06-17 05:12 218阅读 0赞

## 从源码的角度了解AsyncTask ##

可能最近时间比较紧张，没有足够的时间去学习新东西，那就利用这紧张的时间再来复习AsyncTask吧。

首先我们应该清楚AsyncTask主要用来实现什么业务，有什么优点，为什么要用它对吧。

**诉求:**  
1. 我们知道，在Android中，如果执行耗时操作，一定不能在主线程中执行，而且更新UI界面又必须在在主线程中操作。  
2. 如果耗时操作比较多，很多人一般情况下就会开启很多子线程去执行耗时任务，所以这样一来，这就给系统带来非常大的负担，随之而来就影响了整个系统和整个App的性能。  
3. 有时候我们在很多业务场景中，需要启动很多线程，那么线程与线程之间的交互，线程之间的通信。

所以针对上面三条诉求(严格来说还有其他的一些诉求)，我们起初会更愿意使用AsyncTask来实现满足这样的诉求，所以AsyncTask不仅可以有效管理线程数量，任务排序调度，还能实现线程之间的通信，还有有效解决android中的ANR，以及UI界面的更新问题，AsyncTask做了这一些列的封装。

public abstract class AsyncTask<Params, Progress, Result> {
        ....}

所以很明显，AsyncTask是一个抽象类，必须继承派生出来一个子类才能使用。

AsyncTask定一个了三个比较有意思的泛型参数：  
**Params：**启动Task的时候需要传入，也就是说调用AsyncTask对象的execute(Params)传入。

@Override
     protected String doInBackground(Integer... integers) {
       return null;
     }

**Progress：** 后台执行的一个百分比值(非严格来说就是这样的)。

@Override
    protected void onProgressUpdate(Integer... values) {
     super.onProgressUpdate(values);//可以更新一些进度信息或者进度条
    }

但是这里需要注意的是，onProgressUpdate(Progress)方法是通过AsyncTask内部一个final修饰的方法publishProgress(Progress)调用的。

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

最后通过发送一个Handler消息MESSAGE\_POST\_PROGRESS，给Handler，我们再看这个Handler如果合理这个消息的(我们先看流程，不要忽略Handler是子线程的还是主线程的，但是能更新进度界面，那肯定是主线程咯)。

private static class InternalHandler extends Handler {
        
      public InternalHandler() {
          super(Looper.getMainLooper());
      }
     @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;
       }
     }
    }

所以大家看到了吧，最后调用了onProgressUpdate方法，然后，所以我们派生继承子类的时候，把这个方法覆盖实现就能处理我们自己业务逻辑上的进度更新，因为publishProgress是一个final类型的，无法被Override。

**Result：**这是后台任务执行完毕后，输出给UI界面的数据，最后后台任务执行完毕，会通过调用onPostExecute(Result)输出给UI线程,所以这个方法执行是在主线程的。

@Override
            protected void onPostExecute(String s) {
                super.onPostExecute(s);
            }

OK，上麦年我们分别简单说了一下三个反泛型参数的意思。  
那么接下来我们再说说几个功能性的成员方法吧。

//在执行后台任务之前可以在这个方法中做一些事情(主线程)
    @MainThread
    protected void onPreExecute() {
    }
    
    //后台任务都放在这个方法中，在后台子线程中执行
    @WorkerThread
    protected abstract Result doInBackground(Params... params);
    
    //后台任务执行进度更新的逻辑放在这个方法中处理,在主线程中执行
    @SuppressWarnings({
       "UnusedDeclaration"})
    @MainThread
    protected void onProgressUpdate(Progress... values) {
    }
    
    //后台任务执行结束，执行结果通过参数传递过来，执行结束的逻辑在这处理，
    //在主线程中执行
    @SuppressWarnings({
       "UnusedDeclaration"})
    @MainThread
    protected void onPostExecute(Result result) {
    }
    
    //取消结束一个任务，调用方法之后，会在之后调用onCancelled(Result)方法
    public final boolean cancel(boolean mayInterruptIfRunning) {
      mCancelled.set(true);
      return mFuture.cancel(mayInterruptIfRunning);
    }
    
    
    //当用户调用取消之后回调，在主线程中执行
    @SuppressWarnings({
       "UnusedParameters"})
    @MainThread
    protected void onCancelled(Result result) {
        onCancelled();
    }

OK，通过在代码中加注释分别介绍了几个方法的功能和使用场景，相信大家都应该能理解。

那既然也介绍了那么多，那就顺带也来写个小Demo，模拟一下下载任务吧。

package com.zhg.views.asynctask.demo;
    import android.os.AsyncTask;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.widget.TextView;
    import java.util.Random;
    public class MainActivity extends AppCompatActivity {
        
        private TextView mTextView;
        private DonwnloadAsyncTask mDownloadAsyncTask ;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            mDownloadAsyncTask = new DonwnloadAsyncTask();
        }
    
        @Override
        protected void onResume() {
            super.onResume();
            //启动任务，传入一个数字100的int类型参数
            mDownloadAsyncTask.execute(100);
        }
    
        @Override
        protected void onPause() {
            super.onPause();
            //当Activity进入onStop的时候调用cancel
            mDownloadAsyncTask.cancel(true);
        }
    
    //派生继承AsyncTask
    private class DonwnloadAsyncTask extends AsyncTask<Integer,Integer,String>{
        
     @Override
     protected String doInBackground(Integer... integers) {
        if(integers!=null && integers[0] !=null) {
            for(int i  = 0 ;i < integers[0] ; i++){
    //把进度通过publishProgress方法提交到主线程中的onProgressUpdate
                publishProgress(i+1);
                try {
                    Thread.sleep(1000);//模拟下载的延时
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        return "执行完毕";//后台任务处理完毕，返回处理结果
     }
    
      @Override
      protected void onProgressUpdate(Integer... values) {
          super.onProgressUpdate(values);
          if(values!=null && values[0]!=null){
              //在这里更新进度
              mTextView.setText(values[0]+"");
          }
      }
    
      @Override
      protected void onPostExecute(String s) {
          super.onPostExecute(s);
          mTextView.setText(s);//显示处理结果
      }
    
       @Override
       protected void onPreExecute() {
           //这个就是在任务启动先获取TextView
           super.onPreExecute();
           mTextView = (TextView) findViewById(R.id.textview);
       }
      }
    }

Demo比较简单，其实主要是想让大家了解这个AsyncTask的用法。  
OK，现在我们就可以开始跟源码来了解原理了。

OK，那就从execute(Params)开始跟代码。

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

代码很简单，就一行代码，但是有一个很重要的细节，在调用executeOnExecutor(sDefaultExecutor, params)，的时候，传递了一个sDefaultExecutor参数，这个参数是啥呢？来看看先。

public static final Executor SERIAL_EXECUTOR = new SerialExecutor();
    private static final int MESSAGE_POST_RESULT = 0x1;
    private static final int MESSAGE_POST_PROGRESS = 0x2;
    private static volatile Executor sDefaultExecutor = SERIAL_EXECUTOR;

SERIAL\_EXECUTOR 是一个Executor ，我们知道Executor 是一个线程执行者，SerialExecutor内部类继承了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向队尾插入元素
        mTasks.offer(new Runnable() {
          public void run() {
            try {
                r.run();
            } finally {
              scheduleNext();//一个任务执行之后，立即安排下一个任务执行
            }
          }
        });
        //最开始mActive 为null，立即安排一个任务执行
        if (mActive == null) {
           scheduleNext();
        }
      }
       protected synchronized void scheduleNext() {
         if ((mActive = mTasks.poll()) != null) {
            //把一个任务交给线程池执行
             THREAD_POOL_EXECUTOR.execute(mActive);
         }
       }
     }

mTasks 很明显，是一个集合，是一个装着任务体的集合，Runnable。  
上面源码的注释我都说清楚了，所以这sDefaultExecutor (SerialExecutor） 其实就一个用来安排一个线程到线程池中去执行，以及存储后台任务的角色。但是这里有一个比较重要的东西，那就是  
THREAD\_POOL\_EXECUTOR，那么我们来看看THREAD\_POOL\_EXECUTOR这个玩意是什么吧。

private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
    private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
    private static final int KEEP_ALIVE_SECONDS = 30;
    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);
    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;
    }

没错，THREAD\_POOL\_EXECUTOR就是一个活生生的线程池，创建了一个  
大小为CORE\_POOL\_SIZE的线程池，这个的大小是多大？默认它是通过获取当前CPU的核数，根据CPU的核数来计算的，也就是说，当CPU核数小于4的时候，线程池为2，当CPU核数大于4个的时候，线程池的默认大小为4。  
写个伪代码让大家理解理解:  
int size = 2；  
int cpuCount = ？；  
if（cpuCount < 4）\{  
size = 2;  
\}else if(cpuCount > 4)\{  
size = 4;  
\}

MAXIMUM\_POOL\_SIZE 这个就是线程池最大的大小，是CPU核数的2倍加1。  
然后在创建了一个任务队列sPoolWorkQueue，这个任务队列最大可以存放128个任务，大家注意，这个128不是线程池的大小，他只是表明这个队列可以存放128个任务而已，这个队列是一个先进先出的队列。

OK，到这里我们也就明白了，然后我们继续恢复到主线上来跟源码吧。

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

这个方法也很简单，先把状态标记为正在执行，然后调用onPreExeceute()方法，这个方法我们很熟悉，这个方法就是在主线程中执行的，用来在任务执行之前执行一些业务，然后把当前参数设置给了mWorker.mParams。  
我们看看这个mWorker是个什么东西。

private final WorkerRunnable<Params, Result> mWorker;
    ....
    private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
        
       Params[] mParams;
    }

我们发现WorkerRunnable是一个抽象类，而且这个抽象类同时还实现Callable接口，定义了一个成员变量Params\[\] mParams，没错，刚刚我们传进来的参数就是赋值给他了。  
先看看Callable是个什么接口。

@FunctionalInterface
    public interface Callable<V> {
            V call() throws Exception;
    }

很简单，就一个call方法，返回result。  
接下来我们看看mWork是在哪里赋值创建的呢?

public AsyncTask() {
        mWorker = new WorkerRunnable<Params, Result>() {
        public Result call() throws Exception {
        mTaskInvoked.set(true);
        Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
               //noinspection unchecked
               Result result = doInBackground(mParams);
               Binder.flushPendingCommands();
               return postResult(result);
         }
        };
        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 是以匿名内部类的方式创建的，然后细心的人可能已经注意到，在call方法中调用了我们特别重要的一个方doInBackground(params)方法，OK，我们先不管，我们继续会到主线跟代码。  
然后就是调用exec的.execute(mFuture)方法，在一开始我们就介绍了AsyncTask默认的sDefaultExecutor ，这个就是用来存储任务，和安排一个任务到线程池去执行的，他不是直接的去执行任务，他最终他会交给线程池去调度一个空闲线程去执行，我们知道把线程池的execute方法，都接受一个Runnable对象，那么这里的mFuture其实就是一个Runnable对象，稍微看看吧。

private final FutureTask<Result> mFuture;

这个我们知道，在上面Async的Task方法中就已经实例化了这个对象，也是通过匿名内部类的方式创建的，Override了一个done方法，需要注意的是，这创建的时候，在它的构造方法中传递了mWorker对象进去了。

从这样来看，也没发现它是一个Runnable，我们继续刨根问题，再看FutureTask是个啥东西。

public class FutureTask<V> implements RunnableFuture<V> {
        
    ...
    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 must be non-null until state is settled to
          // prevent concurrent calls to run()
            runner = null;
         // state must be re-read after nulling runner to prevent
         // leaked interrupts
           int s = state;
           if (s >= INTERRUPTING)
               handlePossibleCancellationInterrupt(s);
          }
      }
    }

到这里大家应该一目了然了吧，这个还真是一个Runnable对象，并且已经实现了run()方法，而且这个run方法里面还拿到我们传递给他的mWorker对象，即Callable c = callable，然后直接调用mWorker的call方法，我们前面分析过，mWorker是通过创建匿名内部WorkerRunnable的方式创建的，他实现了Callable接口，Callable有一个call方法，而我们也发现，在mWorker的call方法中调用doInBackground(…)方法，就这样，我们的后台任务业务代码，就这样在子线程中得以执行了。

OK，我们继续回到主线，我们把任务提交给了线程池执行之后，如果任务执行完了，怎么回调我们的onPostExecute(Result)呢？

我们这时候应该回到WorkerRunnable的call方法中去，发现doInBackground方法后面还有一行特别关键的代码，即

对，没错，就是postResult(result);很明显，从字面理解就是，提交处理结果。我们去看看这个方法怎么处理的，怎么把结果抛给主线程方法onPostExecute()方法中去的。

private Result postResult(Result result) {
    @SuppressWarnings("unchecked")
    Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,new AsyncTaskResult<Result>(this, result));
    message.sendToTarget();
        return result;
    }
    .....
    
        @SuppressWarnings({
       "RawUseOfParameterizedType"})
        private static class AsyncTaskResult<Data> {
            final AsyncTask mTask;
            final Data[] mData;
    
            AsyncTaskResult(AsyncTask task, Data... data) {
                mTask = task;
                mData = data;
            }
        }

现在我们的代码比较熟悉了把，直接创建了一个Message，我们都知道Mesage一般都是和Handler结合使用的。  
终于我发现下一行代码就直接调用了getHandler()获取一个Handler对象来产生了一个Message对象，我们知道用Handler的obtainMessage方法缠身的Message对象，起内部的target默认就是当前这个Handler。  
所以最后我们把处理结果进行了封装，封装成AsyncTaskResult，AsyncTaskResult中的mTask接收的就是构造方法中传递的this，而mData就是构造方法中传递过来的result，最后把消息发送了出去，那么无可厚非，我么那直接看Handler怎么创建和怎么处理消息的把。

private static Handler getHandler() {
            synchronized (AsyncTask.class) {
                if (sHandler == null) {
                    sHandler = new InternalHandler();
                }
                return sHandler;
            }
        }

代码很简单，创建了一个静态的方法，静态方法中创建了一个InternalHandler对象，那么这个对象很明显就是一个Handler。

private static class InternalHandler extends Handler {
        
     public InternalHandler() {
         super(Looper.getMainLooper());
     }
    @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;
       }
     }
    }

所以到这里大家都很清楚了，Handler创建的时候，构造方法中传递的Looper是MainLooper，即主线程的Looper，所以onProgressUpdate和onPostExecute方法最终是在主线程执行的 , 最后调用了result.mTask.finish(result.mData\[0\]);  
result 我们知道是AsyncTaskResult对象，mTask其实就是AsyncTask自己，最后调用了AsyncTask的finish(…)我们来看看把。

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

很简单最后，我就不说了，大家都明白。其实呢，到这里基本讲完了。  
最后说说AsyncTask平时使用的一些细节。

我们知道，最新的AsyncTask，在很多方面都已经得到改进，比如，线程池的问题，我们就已经发现很多好处，不知道大家通过上面的分析， 有没有注意到，其实executeOnExecutor是一个public的方法，这个方法第一个参数接受一个Executor 的参数，这是一个非常好的有点，一个扩展点，如果那天AsyncTask内部默认维护的线程池我们满足不了我么你的需求，我们可以通过外界传递一个自定义的线程池。

另外还有注意几点:  
1.AsyncTask的实例必须在UI thread中创建，并且execute方法必须在UI thread中调用，但其实我个人认为这也是一个缺点，如果我不在UI线程中创建，那onPreExecute()方法执行就是在子线程中了，但是往往onPreExecute方法很多业务逻辑都在UI线程。

1.  不要自己手动的调用  
    onPreExecute(),  
    onPostExecute(Result)，  
    doInBackground  
    onProgressUpdate(Progress…)这几个方法
2.  该task只能被执行一次，否则多次调用时将会出现异常。