AsyncTask的源码分析

2019-05-04 本文已影响0人 dashingqi

好记性不如烂笔头，把自己会的用自己的话给记录下来，写成文章，供自己日后查阅。慢慢积累，终会有用到的那天。

基本介绍

AsyncTask 定义（翻译Android的官方文档）
1. AsyncTask能够简单方便使用UI线程。这个类允许你在后台执行任务并且将执行后的结果在UI线程中显示出来不需要通过去开启线程和消息的方式。
2. AsyncTask被设计的目的是为了成为Thread和Handler的帮助类，但是不能成为一个通用的线程框架。AsyncTask是用于短的耗时任务中（也就几秒钟的耗时任务吧！）。如果你需要去长期的在后台执行耗时任务，很强烈的推荐你去使用java.util.concurrent包下的Executor，ThreadPoolExecutor和Future这几个API。
3. 一个异步任务被设计用来计算跑在后台任务的结果（一般获取任务进度来更新UI），然后将结果展示在UI线程中。一个异步任务由三个范型参数和4个方法来实现。（三个范型参数：Params，Progress，Result；4个方法：onPreExecute,doInBackground,onProgressUpdate,onPostExecute）

AsyncTask使用基本介绍

各个方法的使用场景介绍
- onPreExecute() ：在UI线程中进行初始化操作，该方法的执行是在UI线程中。
- doInBackground()：执行耗时的操作任务，执行在工作线程中（开启一个新的线程）
- onProgressUpdate()：更新任务执行的进度（主要就是更新UI，该方法如果想要执行，需要在doInBackground()中执行publishProgress()来触发刚方法的执行，这个会在源码分析部分，根据源码来说明）执行在UI线程中。
- onPostExecute：最终任务执行的结果会返回到这个方法中，也是执行在UI线程中，主要处理些结尾的操作。

使用AsyncTask的基本步骤

AsyncTask是一个抽象类，需要子类继承AsyncTask并且实现内部的抽象方法

 class MyTask extends AsyncTask<Void,Integer,Void>{ 
    @Override
     protected Void doInBackground(Void... voids) {
          ...... //执行耗时的任务操作，该方法是必须被实现的。
      }
  }

开启异步任务

    //开启异步任务，（这个参数可以不传，这个地方不传的话，AsyncTask中第一个范型参数就可以写成Void类型了） 这段代码必须在UI线程中去执行
    // new MyTask()任务实例的初始化 和 execute方法的调用都必须在UI线程中。
    new MyTask().execute(params)

展示一个AsyncTask异步任务的小demo

private  class MyTask extends AsyncTask<Void,Integer,Void>{

  @Override
  protected void onPreExecute() {
    mTvShowLoading.setText("加载中");
  }

@Override
protected Void doInBackground(Void... voids) {
    int count = 0;
    int length =1;
    int tempCount = 99;
    while(count < tempCount){
    count += length;
    //将执行任务的实时结果 传入到UI线程中进行UI的更新
    // 该方法的调用时为了触发onProgressUpdate(params)的方法，params[0]参数就是onProgressUpdate(Integer..values) 方法中的 values[0]的参数
    publishProgress(count);
    try {
          //这个地方是为了模拟进度的效果，实际使用中，不能这么搞呀！
        Thread.sleep(500);
    } catch (InterruptedException e) {
        e.printStackTrace();
      }
  }
  return null;
}

@Override
protected void onProgressUpdate(Integer... values) {
  progressBar.setProgress(values[0]);
  mTvShowLoading.setText("loading ..."+values[0]+"%");
}

  @Override
  protected void onPostExecute(Void aVoid) {
      mTvShowLoading.setText("加载完毕");
  }
 }

AsyncTask使用场景
- 执行耗时的任务，并且要实时更新主线程的UI
- 如果你仅仅执行耗时的任务，没必要使用AsyncTask。可以使用Executor FutureTask的。
- 如果是大规模的下载和数据库的更改不适合使用AsyncTask。会导致线程阻塞的。

源码分析

AsyncTask构造方法

API == 25：

 //source
 public AsyncTask() {
 //工作线程 WorkerRunnable是一个Callable接口的实现类，Callable类型接口有返回值
 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;
     }
 };

 //入参了mWorker参数
 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);
         }
     }
   };
}

WorkRunnable

分析

 //source
  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 {
             //分析1 （提交任务结果）
             postResult(result);
         }
         return result;
     }
 };
 //分析1 
 private Result postResult(Result result) {
   @SuppressWarnings("unchecked")
   //getHandler()返回的就是mHandler == AsyncTask构造方法中赋值的mHandler  
   //这段代码是构造一个Message对象
   Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
         new AsyncTaskResult<Result>(this, result));
   // sendToTarget方法的实现就是通过handler将消息发送出去，根据标志执行不能的逻辑代码，
   //也实现了从工作线程切换到Ui线程上。
   message.sendToTarget();
   return result;
}

//这是一个单利模式，来获取到InternalHanlder的实例。
//接着查看InterHandler类。
private static Handler getHandler() {
 synchronized (AsyncTask.class) {
     if (sHandler == null) {
         sHandler = new InternalHandler();
     }
     return sHandler;
 }
}
//AsyncTask内部的一个Handler，主要用来发送任务更新UI的消息和任务完成的消息。
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;
         //发送任务更新UI的消息，来执行onProgressUpdate()方法。
         case MESSAGE_POST_PROGRESS:
             result.mTask.onProgressUpdate(result.mData);
             break;
     }
 }
}

FutureTask

分析

  //source 
  //参数中传入了上文中构造好的 WorkRunnable的对象
  mFuture = new FutureTask<Result>(mWorker) {
      @Override
      protected void done() {
          try {
                //重点分析1
              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);
          }
      }
  };
  
//重点分析1 
 private void postResultIfNotInvoked(Result result) {
  //获取到执行任务的标志
  final boolean wasTaskInvoked = mTaskInvoked.get();
  //如果任务没有得到执行，那么直接就提交任务
  if (!wasTaskInvoked) {
      postResult(result);
    }
}

execute

分析

  //source
  //运行在主线程中
@MainThread
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
    // 此处看 executeOnExecutor()
    // 其中sDefaultExecutor =  new SerialExecutor();  
    return executeOnExecutor(sDefaultExecutor, params);
}

  // executeOnExecutor() 分析
  @MainThread
// 此处的exec 就是SerialExecutor
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)");
        }
    }

    //初始化AsyncTask状态为RUNNING(运行的状态)
    mStatus = Status.RUNNING;

    //主线程的UI初始化操作
    onPreExecute();

    //将参数添加到任务中，此处的params就是调用在主线程中调用execute(Params)传入的参数，该参数最终会进入到doInBackground()方法中。
    mWorker.mParams = params;
    //执行任务
    // 此处的exec =  sDefaultExecutor = new SerialExecutor();
    // SerialExecutor 是AsyncTask的一个静态内部类，实现了Execute接口，重写了Execute方法。
    exec.execute(mFuture);
    return this;
}

// SerialExecutor 排队线程池,这也是AsyncTask能串行执行的关键，内部的实现就是按顺序执行任务。
//所以就达到了任务串行执行的目的。
//在上文中我们分析 execute方法的时候 我们在execute方法中调用了executeOnExecutor(sDefaultExecutor, params);
// 其中的 sDefaultExecutor就是SerialExecutor的实例，所以可以看出来如果想要做并行执行任务，可以在这个executeOnExecutor()方法入参上做文章。
private static class SerialExecutor implements Executor {
    //此处是一个线性双向列表，用来存储所有的AsyncTask的任务
    final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
    //正在执行的任务
    Runnable mActive;

    public synchronized void execute(final Runnable r) {
        //将任务添加到队列中  offer：在队列的末尾插入一个值
        mTasks.offer(new Runnable() {
            public void run() {
                try {
                    // r = mFuture
                    // 执行了FutureTask的run方法
                    //查看run方法 发现内部又调用了WorkRunnable的call方法
                    //这时内存中的WorkRunnable中的call方法得以执行，内部就执行了doInBackground方法。
                    r.run();
                } finally {
                    //当前的任务执行完毕后，进行下一轮任务的执行。
                    //在这里也很好的体现了AsyncTask的串行执行任务的机制。
                    scheduleNext();
                }
            }
        });
        if (mActive == null) {
            scheduleNext();
        }
    }

    protected synchronized void scheduleNext() {
        //取出队列头部的任务 poll：删除队列中的第一个值，并返回该值，如果不存在就返回null。
        if ((mActive = mTasks.poll()) != null) {
            //执行取出的队列头部的任务
            //就是调用了任务线程类 THREAD_POOL_EXECUTOR
            //接下来就是分析了 THREAD_POOL_EXECUTOR.executor
            // THREAD_POOL_EXECUTOR 执行线程池
            THREAD_POOL_EXECUTOR.execute(mActive);
        }
    }
}

// THREAD_POOL_EXECUTOR 分析：执行任务的线程池

//获取到CPU核心数
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
//设置线程池的核心线程数 为 2-4之间 ，也取决于cup的核数
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;
//设置线程池的空闲线程存活的时间为30秒
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());
    }
};

// 初始化好存储任务队列。最大数量为128个
private static final BlockingQueue<Runnable> sPoolWorkQueue =
        new LinkedBlockingQueue<Runnable>(128);
//定义一个 Executor类型的变量，名称为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);
    //设置线程池的超时时间为30秒
    threadPoolExecutor.allowCoreThreadTimeOut(true);
    THREAD_POOL_EXECUTOR = threadPoolExecutor;
}

总结

流程总结
- AsyncTask = 两个线程池+ 一个Handler
- 这两个线程池：SerialExecutor和THREAD_POOL_EXECUTE
- Handler：就是InternalHandler，主要用来进行消息的发送，将线程从工作线程切换到UI线程上，来进行UI的更新。
知识点总结
- 串行还是并行？
  1. API 1.6 之前是串行的。
  2. API 1.6 - 3.0 由串行给改成并行，多任务执行。
  3. 但是到API 3.0 的时候由于之前并行并发执行任务出现错误，所以给改成串行执行，直到现在最新的版本还是串行执行的。因为线程池的容量最高设定为128个，如果出现129个并行执行的话，就会出现Crash线程，导致应用程序崩溃，所以Google由串行改成并行就是画蛇添足，所以在3.0的时候改成串行了，一直保持到现在。
- 那么现在就不能并行执行任务了吗？
  1. 肯定能的呀！
  2. 下面使用AsyncTask来写一段并行执行的代码。
```
  //example 
  new MyTask("AsyncTask1").executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR,"");
  new MyTask("AsyncTask1").executeOnexecutor(AsyncTask.THREAD_POOL_EXECUTOR,"")；
   //不过注意的是 executeOnExecutor()该方法是在android3.0加入的，在低版本中是不能执行的，需要加上版本的判断，不过现在市面上应该没有android3.0 以下的手机了吧！
```
- 内存泄漏的那些事
  1. 内部类默认持有外部类的引用：在调用内部类的构造函数初始化内部类对象时，会默认传入外部类的引用。
  2. 问题发生的分析
    
    在AsyncTask中，如果在执行耗时的异步任务的时候，当Activity结束的时候，此时AsyncTask还在后台运行着，此时AsyncTask还持有了Activity的引用，，GC就不能正常回收Activity的的引用，那么就会发生内存泄漏了！
  3. 内存泄漏问题的解决方式。
    - 在Activity的onDestroy()方法中调用AsyncTask的onCancelled()方法。当AsyncTask中没有任务在执行的时候，GC会在合适的时候把AsyncTask所引用的Activity和AsyncTask实例给回收掉。
    - 声明为静态的内部类。

可能有不足或者有错误的地方，欢迎多多指教。

AsyncTask的源码分析

基本介绍

源码分析

总结

猜你喜欢

热点阅读