About ExecutorService(4),AsyncTask番外篇

时间:2022-06-07
本文章向大家介绍About ExecutorService(4),AsyncTask番外篇,主要内容包括其使用实例、应用技巧、基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋友可以参考一下。

这些小知识点作为AT的番外篇再适合不过了。

直接切入正题,我们都知道AT在3.X将默认的线程池由并行改为串行,真的是众所周知的3.0(HONEYCOMB)开始的嘛?答案是否定的。确切的说是从3.2(HONEYCOMB_MR1)起。

我们拿Android-22举个例子,根据路径打开,<Sdk根目录>sourcesandroid-22androidappActivityThread.java,找到这样的一段代码(源码没有那段中文注释)

// If the app is Honeycomb MR1 or earlier, switch its AsyncTask
// implementation to use the pool executor.  Normally, we use the
// serialized executor as the default. This has to happen in the
// main thread so the main looper is set right .
if (data.appInfo.targetSdkVersion <= android.os.Build.VERSION_CODES.HONEYCOMB_MR1) {  
 /*设置默认线程池*/
 AsyncTask.setDefaultExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}

接下来我们只需要对照android.os.Build.VERSION_CODES,找到HONEYCOMB_MR1代表哪个版本就OK了。

蜂巢3.1

由此便可得出结论,3.2及其之后,AT的线程池使用串行代替并行。

但是...... 前两天做消息推送的时候需要使用一些Android的Compat(兼容)包或类。于是今天好奇的想看看AT有没有兼容包或者类,于是就发现了这个AsyncTaskCompat类,这个类的主要功能就是提供一个并行线程池的AT(Parallel:并行)。位于<SDK根目录>extrasandroidm2repositorycomandroidsupportsupport-v422.2.0support-v4-22.2.0-sources.jar!androidsupportv4osAsyncTaskCompat.java

代码很简短,如下:

/**
  * Helper for accessing features in {@link android.os.AsyncTask}
  * introduced after API level 4 in a backwards compatible fashion.
  */
public class AsyncTaskCompat {
/**
 * Executes the task with the specified parameters, allowing multiple tasks to run in parallel
 * on a pool of threads managed by {@link android.os.AsyncTask}.
 *
 * @param task The {@link android.os.AsyncTask} to execute.
 * @param params The parameters of the task.
 * @return the instance of AsyncTask.
 */
public static <Params, Progress, Result> AsyncTask<Params, Progress, Result> executeParallel(
        AsyncTask<Params, Progress, Result> task,
        Params... params) {
    if (task == null) {
        throw new IllegalArgumentException("task can not be null");
    }
    if (Build.VERSION.SDK_INT >= 11) {
        // From API 11 onwards, we need to manually select the THREAD_POOL_EXECUTOR
        AsyncTaskCompatHoneycomb.executeParallel(task, params);
    } else {
        // Before API 11, all tasks were run in parallel
        task.execute(params);
    }
    return task;
  }
}

接下来:

`AsyncTaskCompat`中部分源码截图

这段代码的注释与ActivityThread中代码的注释有冲突,之前明确指出只有13及其之后才会使用串行线程池代替并行。个人观点更倾向于这样,显得规范一些:

if (Build.VERSION.SDK_INT >= 13) {
        // From API 13 onwards, we need to manually select the THREAD_POOL_EXECUTOR
        AsyncTaskCompatHoneycomb.executeParallel(task, params);
    } else {
        // Before API 13, all tasks were run in parallel
        task.execute(params);
    }

虽然之前的写法并没有错,但很容易给开发者带来困惑。

既然这里又提到了并发,就不得不提一下有关“锁”的优化,确切的说是AT中“锁”的优化。

多核时代的来临,使用多线程可以显著提高系统的性能,但是,单线程真的“一无是处”了吗,答案依然是否定的,对于那些单线程或者单任务的程序来说,主要资源都消耗在任务本身,既不需要维护并行数据结构间的一致性状态,也不需要为线程的切换和调度花费不必要的时间,而且,对于多线程而言,系统除了处理任务外,还需要维护多线程环境的特有信息,比如:线程本身的数据元,线程调度,甚至是线程上下文的切换等。

事实上,在单核CPU(然而单核mobile并没有什么卵用)上,采用并行算法的效率一般要低于原始的串行算法。因此,并行计算之所以能够提高系统的性能,并不是因为线程偷懒,少干活,而是因为并行计算可以更合理的进行任务调度。所以,合理的并发,才能将多核CPU(真·八核?!)的性能发挥效果。

然而,在多核,多线程,多任务时代,为了保证数据的同步,“锁”扮演着不可或缺的角色。优雅的异步,并行,并发等算法结构,都离不开“锁”,然而,激烈的锁竞争又会导致程序性能的下降。

因此,在使用“锁”的时候,我们也应该尽量考虑以下几点:

  • 减少锁持有时间

只在必要时进行同步,这样就能明显减少线程持有锁的时间,提高系统的吞吐量

  • 减小锁粒度

缩小锁定对象的范围,从而减少锁冲突的可能性,进而提高系统的并发能力,例如ConcurrentHashMap的桶锁机制。

  • 重用锁(ReentrantLock)代替内部锁(synchronized

重用锁提供了很多内部锁不具备的强大功能,比如锁等待时间( boolean tryLock(long timeout, TimeUnit unit))、支持中断锁(void lockInterruptibly( ))等,这些API有助于避免死锁,提高系统稳定性,使用ReentrantLock一定要注意在finally中释放。

  • 粗化锁

这个解释起来比较笼统,与减少锁持有时间在含义上是相反的。因为锁的竞争与释放,也是需要消耗资源的,因此当我们需要在循环内请求锁时, 需要写成这样:

   synchronized (this) {
      for (int i = 0; i < count; i++) {
        /*do something*/
    }
  }

而不是这样:

  for (int i = 0; i < count; i++) {
     synchronized (this) {
       /*do something*/
    }
  }

接下来看一段AT中的源码:

AT部分源码

使用线程安全的双端队列LinkedBlockingDeque代替ArrayDeque,从而可以减少锁持有时间,使用重用锁(ReentrantLock)代替内部锁(synchronized)进行双重校验,避免高并发状态下scheduleNext方法不必要的锁等待。

private static class SerialExecutor implements Executor {
  final LinkedBlockingDeque<Runnable> mTasks = new LinkedBlockingDeque<>();
  Runnable mActive;
  final ReentrantLock reentrantLock = new ReentrantLock();

public void execute(final Runnable r) {
  mTasks.offer(new Runnable() {
    public void run() {
      try {
        r.run();
      } finally {
        SerialExecutor.this.scheduleNext();
      }
    }
  });

  if (mActive == null) {
    reentrantLock.lock();
    try {
      if (mActive == null) {
        SerialExecutor.this.scheduleNext();
      }
    } finally {
      reentrantLock.unlock();
    }
  }
}

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

差不多这就是这样了,如果有理解不当,或逻辑错误,还望指出。

片尾TIP:

一张图足够说明了。

Android studio生成style和include