进阶之路 | 奇妙的Thread之旅

## 前言 > 本文已经收录到我的Github个人博客，欢迎大佬们光临寒舍： > > [我的GIthub博客](https://lovelifeeveryday.github.io/) ## 需要已经具备的知识： - `Thread`的基本概念及使用 - `AsyncTask`的基本概念及使用 ## 学习导图：  ## 一.为什么要学习`Thread`? 在`Android`中，几乎完全采用了`Java`中的线程机制。线程是最小的调度单位，在很多情况下为了使`APP`更加流程地运行，我们不可能将很多事情都放在主线程上执行，这样会造成严重卡顿（`ANR`），那么这些事情应该交给子线程去做，但对于一个系统而言，创建、销毁、调度线程的过程是需要开销的，所以我们并不能无限量地开启线程，那么对线程的了解就变得尤为重要了。 本篇文章将带领大家由浅入深，从**线程的基础**，谈到**同步机制**，再讲到**阻塞队列**，接着提及**`Android`中的线程形态**，最终一览**线程池机制**。 话不多说，赶紧开始奇妙的`Thread`之旅吧！ ## 二.核心知识点归纳 ### 2.1 线程概述 Q1：**含义** 线程是`CPU`调度的最小单位 > 注意与进程相区分 Q2：**特点** 线程是一种**受限**的系统资源。即线程不可无限制的产生且线程的创建和销毁都有一定的开销 >**Q**：如何避免频繁创建和销毁线程所带来的系统开销？ >**A**：采用**线程池**，池中会缓存一定数量的线程，进而达到效果 Q3:**分类** - 按用途分为两类： > - **主线程**:一般一个进程只有一个主线程，主要处理**界面交互**相关的逻辑 > > - **子线程**：除主线程之外都是子线程，主要用于执行**耗时操作** - 按形态可分为三类： > - `AsyncTask`：底层封装了线程池和`Handler`，便于执行后台任务以及在主线程中进行`UI`操作 > - `HandlerThread`：一种具有**消息循环**的线程，其内部可使用`Handler` > - `IntentService`:一种**异步、会自动停止**的服务，内部采用`HandlerThread`和`Handler`  PS：想详细了解`Handler`机制的读者，推荐一篇笔者的文章：[进阶之路 | 奇妙的Handler之旅](https://juejin.im/post/5e61bf2de51d4526ea7f00bd) Q4：**如何安全地终止线程？** >对于有多线程开发经验的开发者，应该大多数在开发过程中都遇到过这样的需求，就是在某种情况下，希望立即停止一个线程 > >比如：做`Android`开发，当打开一个界面时，需要开启线程请求网络获取界面的数据，但有时候由于网络特别慢，用户没有耐心等待数据获取完成就将界面关闭，此时就应该立即停止线程任务，不然一般会内存泄露，造成系统资源浪费，如果用户不断地打开又关闭界面，内存泄露会累积，最终导致内存溢出，`APP`闪退 > >所以，笔者希望能和大家探究下：如何安全地终止线程？ A1：**为啥不使用`stop`?** > Java官方早已将它废弃，不推荐使用 - `stop`是通过立即抛出`ThreadDeath`异常，来达到停止线程的目的，此异常抛出有可能发生在任何一时间点，包括在`catch`、`finally`等语句块中，但是此异常并不会引起程序退出 - 异常抛出，导致线程会**释放**全部所持有的**锁**，极可能引起**线程安全**问题 A2：**提供单独的取消方法来终止线程** 示例`DEMO`： ```java public class MoonRunner implements Runnable { private long i; //注意的是这里的变量是用volatile修饰 volatile boolean on = true; @Override public void run() { while (on) { i++; } System.out.println("sTop"); } //设置一个取消的方法 void cancel() { on = false; } } ``` > 注意：这里的变量是用`volatile`修饰，以保证**可见性**，关于`volatile`的知识，笔者将在下文为您详细解析 A3：**采用`interrupt`来终止线程** `Thread`类定义了如下关于中断的方法：  原理： - 调用`Thread`对象的`interrupt`函数并不是立即中断线程，只是将线程**中断**状态**标志**设置为`true` - 当线程运行中有调用其阻塞的函数时，阻塞函数调用之后，会不断地轮询检测中断状态标志是否为`true`，如果为`true`，则停止阻塞并抛出`InterruptedException`异常，同时还会重置中断状态标志，因此需要在`catch`代码块中需调用`interrupt`函数，使线程再次处于中断状态 - 如果中断状态标志为`false`，则继续阻塞，直到阻塞正常结束 >具体的`interrupt`的使用方式可以参考这篇文章：[Java线程中断的正确姿势](https://www.jianshu.com/p/264d4e1b76af) ### 2.2 同步机制 #### 2.2.1 `volatile` > - 有时候仅仅为了读写一个或者两个实例就使用同步`synchronized`的话，显得开销过大 > - 而`volatile`为实例域的同步访问提供了免锁的机制 Q1：**先从`Java`内存模型聊起** - `Java` 内存模型定义了**本地内存和主存**之间的抽象关系 > - 线程之间的**共享变量**存储在**主存**中 > - 每个线程都有一个**私有的本地内存**（工作内存），本地内存中存储了该线程共享变量的**副本**。  - 线程之间通信的步骤 > - 线程**A**将其**本地内存**中**更新过的共享变量刷新到主存**中去 > - 线程**B**到**主存**中去**读取**线程A之前已**更新过的共享变量** Q2：**`原子性、可见性和有序性`了解多少** a1：**原子性`Atomicity`**： - 定义：原子性操作就是指这些操作是不可中断的，要做一定做完，要么就没有执行 - 对基本数据类型变量的**读取和赋值**操作是原子性操作 > 注意：这里的**赋值**操作是指**将数字赋值给某个变量** 下面由`DEMO`解释更加通俗易懂 ```java x=3; //原子性操作 y=x; //非原子性操作 原因：包括2个操作：先读取x的值，再将x的值写入工作内存 x++; //非原子性操作 原因：包括3个操作：读取x的值、对x的值进行加1、向工作内存写入新值 ``` - `volatile`不支持原子性（想探究原因的，笔者推荐一篇文章：[面试官最爱的volatile关键字](https://juejin.im/post/5a2b53b7f265da432a7b821c#heading-2)） - 保证整块代码原子性（例如`i++`）的方法：借助于`synchronized`和`Lock`，以及并发包下的`atomic`的原子操作类 a2：**可见性`Visibility`** - 定义：一个线程修改的结果，另一个线程马上就能看到 - `Java`就是利用`volatile`来提供可见性的 > 原因：当一个变量被`volatile`修饰时，那么对它的修改会**立刻刷新到主存**，同时使**其它线程的工作内存**中对此变量的**缓存行失效**，因此需要读取该变量时，会去内存中读取新值 - 其实通过`synchronized`和`Lock`也能够保证可见性，但是`synchronized`和`Lock`的开销都更大 a3：**有序性`Ordering`** - **指令重排序**的定义：大多数现代微处理器都会采用将指令乱序执行的方法, 在条件允许的情况下, 直接运行当前有能力立即执行的后续指令, 避开获取下一条指令所需数据时造成的等待 - 什么时候不进行**指令重排序**： > - 符合数据依赖性： > > ```java > //x对a有依赖 > a = 1; > x = a; > ``` > > - `as-if-serial`语义：不管怎么重排序, 单线程程序的执行结果不能被改变 > - 程序顺序原则 > > 1. 如果A `happens-before` B > 2. 如果B `happens-before` C > 3. 那么A `happens-before` C > > 这就是`happens-before`传递性 - `volatile`通过**禁止指令重排序**的方式来保证有序性 Q3：**应用场景有哪些？** - 状态量标记 > 线程的终止的时候的状态控制,示例DEMO如前文 - `DCL` > 避免指令重排序： > > 假定创建一个对象需要: > > 1. 申请内存 > 2. 初始化 > 3. `instance`指向分配的那块内存 > > 上面的2和3操作是有可能重排序的, 如果3重排序到2的前面, 这时候2操作还没有执行, `instance！=null`, 当然不是安全的 ```java class Singleton{ private volatile static Singleton instance = null; private Singleton() {} public static Singleton getInstance() { if(instance==null) { synchronized (Singleton.class) { if(instance==null) instance = new Singleton(); } } return instance; } } ``` Q4：原理： - 如果把加入`volatile`关键字的代码和未加入`volatile`关键字的代码都生成汇编代码，会发现加入`volatile`关键字的代码会多出一个`lock`前缀指令 - `lock`前缀指令实际相当于一个**内存屏障**，内存屏障提供了以下功能： > - 重排序时不能把后面的指令重排序到内存屏障之前的位置 > - 使得本`CPU`的`Cache`写入内存 > - 写入动作也会引起别的`CPU`或者别的内核无效化其`Cache`，相当于让新写入的值对别的线程可见 #### 2.2.2 重入锁与条件对象 > `synchronized` 关键字自动为我们提供了锁以及相关的条件，大多数需要显式锁的时候，使用`synchronized` 非常方便，但是当我们了解了重入锁和条件对象时，能更好地理解`synchronized` 和阻塞队列 Q1：**重入锁的定义** - 可重入锁指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁，这样的锁就叫做可重入锁 - `ReentrantLock`和`synchronized`都是可重入锁 > 重复调用锁的`DEMO`如下： ```java public class ReentrantTest implements Runnable { public synchronized void get() { System.out.println(Thread.currentThread().getName()); set(); } public synchronized void set() { System.out.println(Thread.currentThread().getName()); } public void run() { get(); } public static void main(String[] args) { ReentrantTest rt = new ReentrantTest(); for(;;){ new Thread(rt).start(); } } } ``` Q2：什么是条件对象`Condition`？ - 条件对象来管理那些已经**获得了一个锁**但是却**不能做有用工作**的线程，条件对象又被称作条件变量 - 一般要配合`ReentrantLock`使用，用`Condition.await()`可以**阻塞当前线程**，并**放弃锁** Q3：下面说明重入锁与条件对象如何协同使用 > - 用**支付宝转账**的例子(支付宝打钱，狗头.jpg) > - 场景是这样的： ```java //转账的方法 public void transfer(int from, int to, int amount){ //alipay是ReentrantLock的实例 alipay.lock(); try{ //当要转给别人的钱大于你所拥有的钱的时候，调用Condition的await可以阻塞当前线程，并放弃锁 while(accounts[from] < amount){ condition.await(); } ...//一系列转账的操作 //阻塞状态解除,进入可运行状态 condition.signalAll(); } finally{ alipay.unlock(); } } ``` > 想要更深一步了解重入锁的读者，可以看下这篇文章：[究竟什么是可重入锁？](https://blog.csdn.net/rickiyeat/articlehttps://img.qb5200.com/download-x/details/78314451) #### 2.2.3 `synchronized` Q1：`synchronized`有哪几种实现方式？ - 同步代码块 - 同步方法 Q2:`synchronized`与`ReentrantLock`的关系 - 两者都是重入锁 - 两者有些方法互相对应 > - `wait`等价于`condition.await()` > - `notifyAll`等价于`condition.signalAll()` Q3：使用场景对比 | 类型 | 使用场景 | | ---------------- | ------------------------------------ | | 阻塞队列 | 一般实现同步的时候使用 | | 同步方法 | 如果同步方法适合你的程序 | | 同步代码块 | 不建议使用 | | `Lock/Condition` | 需要使用`Lock/Condition`的独有特性时 | ### 2.3 阻塞队列 > 为了更好地理解线程池的知识，我们需要了解下阻塞队列 Q1:**定义** - 阻塞队列`BlockingQueue`是一个支持两个附加操作的队列。这两个附加的操作是： > - 在队列为空时，获取元素的线程会等待队列变为非空 >- 当队列满时，存储元素的线程会等待队列可用 Q2:**使用场景**： 阻塞队列常用于生产者和消费者的场景，生产者是往队列里添加元素的线程，消费者是从队列里拿元素的线程。阻塞队列就是生产者存放元素的容器，而消费者也只从容器里拿元素。 Q3:**核心方法** | 方法\处理方式 | 抛出异常 | 返回特殊值 | 一直阻塞 | 超时退出 | | :------------ | :---------- | :--------- | :------- | :------------------- | | 插入方法 | `add(e)` | `offer(e)` | `put(e)` | `offer(e,time,unit)` | | 移除方法 | `remove()` | `poll()` | `take()` | `poll(time,unit)` | | 检查方法 | `element()` | `peek()` | 不可用 | 不可用 | Q4：**`JAVA`中的阻塞队列** | 名称 | 含义 | | ----------------------- | ------------------------------------------------------------ | | `ArrayBlockingQueue` | 由**数组**结构组成的**有界**阻塞队列（最常用） | | `LinkedBlockingQueue` | 由**链表**结构组成的**有界**阻塞队列（最常用）注意：一定要指定大小 | | `PriorityBlockingQueue` | 支持**优先级排序**的**无界**阻塞队列。默认自然升序**排列** | | `DelayQueue` | 支持**延时**获取元素的无界阻塞队列。 | | `SynchronousQueue` | **不存储**元素的阻塞队列（可以看成是一个传球手，负责把生产者线程处理的数据直接传递给消费者线程） | | `LinkedTransferQueue` | 由**链表**结构组成的**无界**阻塞队列 | | `LinkedBlockingDeque` | 由**链表**结构组成的**双向阻塞**队列（双向队列指的是可以从队列的两端插入和移出元素） |  Q5：**实现原理：** - 底层利用了`ReentrantLock`&`Condition`来实现自动加锁和解锁的功能 - 如果想详细了解阻塞队列实现原理的源码，笔者推荐一篇文章：[Android并发学习之阻塞队列](https://juejin.im/post/5b21ded3e51d4506bb3a84b6) ### 2.4 `Android`中的线程形态 #### 2.4.1 `AsyncTask` Q1：**定义**：一种轻量级的**异步**任务类 >在`Android`中实现异步任务机制有两种方式：[Handler](https://juejin.im/post/5e61bf2de51d4526ea7f00bd)和`AsyncTask` > >- `Handler`机制存在的**问题**：代码相对臃肿；多任务同时执行时不易精确控制线程。 >- 引入`AsyncTask`的**好处**：创建异步任务更简单，直接继承它可方便实现后台异步任务的执行和进度的回调更新UI，而无需编写任务线程和`Handler`实例就能完成相同的任务。 Q2:**五个核心方法：** | 方法 | 运行线程 | 调用时刻 | 作用 | | -------------------- | -------- | ------------------------------------------------ | ------------------------------------------------------------ | | `onPreExecute()` | 主线程 | 在异步任务执行之前被调用 | 可用于进行一些界面上的**初始化**操作 | | `doInBackground()` | 子线程 | 异步任务执行时 | 可用于处理所有的**耗时任务**。若需要更新`UI`需调用 `publishProgress()` | | `onProgressUpdate()` | 主线程 | 调用`publishProgress()`之后 | 可利用方法中携带的参数如`Progress`来对`UI`进行相应地更新 | | `onPostExecute()` | 主线程 | 在异步任务执行完毕并通过`return`语句返回时被调用 | 可利用方法中返回的数据来进行一些**UI**操作 | | `onCancelled()` | 主线程 | 当异步任务被取消时被调用 | 可用于做**界面取消**的更新 | > 注意： > > - 不要直接调用上述方法 > - `AsyncTask`对象必须在**主线程**创建 Q3：**开始和结束异步任务的方法** - `execute()` > - 必须在**主线程**中调用 > - 作用：表示开始一个异步任务 > - 注意：一个异步对象只能调用一次`execute()`方法 - `cancel()` > - 必须在**主线程**中调用 > - 作用：表示停止一个异步任务 Q4:工作原理： - 内部有一个静态的`Handler`对象即`InternalHandler` > - 作用：将执行环境从线程池切换到主线程；通过它来发送任务执行的进度以及执行结束等消息 > > - 注意：必须在主线程中创建 - 内部有两个线程池： > - `SerialExecutor`：用于任务的排队，默认是**串行**的线程池 > - `THREAD_POOL_EXECUTOR`：用于真正执行任务 - 排队执行过程： > - 把参数`Params`封装为`FutureTask`对象，相当于`Runnable` > - 调用`SerialExecutor.execute()`将`FutureTask`插入到任务队列`tasks` > - 若没有正在活动的`AsyncTask`任务，则就会执行下一个`AsyncTask`任务。执行完毕后会继续执行其他任务直到所有任务都完成。即默认使用**串行**方式执行任务。 执行流程图：  **注意**：`AsyncTask`不适用于进行特别耗时的后台任务，而是建议用线程池 > 如果想要了解具体源码的读者，笔者推荐一篇文章：[Android AsyncTask完全解析，带你从源码的角度彻底理解](https://blog.csdn.net/guolin_blog/articlehttps://img.qb5200.com/download-x/details/11711405) #### 2.4.2 `HandlerThread` Q1：定义： `HandlerThread`是一个线程类，它继承自`Thread` > 与普通`Thread`的区别：具有**消息循环**的效果。原理： > > - 内部`HandlerThread.run()`方法中有`Looper`，通过`Looper.prepare()`来创建消息队列，并通过`Looper.loop()`来开启消息循环 Q2：实现方法 - 实例化一个`HandlerThread`对象，参数是该线程的名称 - 通过 `HandlerThread.start()`开启线程 - 实例化一个`Handler`并传入`HandlerThread`中的`Looper`对象，使得与`HandlerThread`绑定 - 利用`Handler`即可执行异步任务 - 当不需要`HandlerThread`时，通过`HandlerThread.quit()`/`quitSafely()`方法来终止线程的执行 ```java private HandlerThread myHandlerThread ; private Handler handler ; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); //实例化HandlerThread myHandlerThread = new HandlerThread("myHandler") ; //开启HandlerThread myHandlerThread.start(); //将Handler对象与HandlerThread线程绑定 handler =new Handler(myHandlerThread.getLooper()){ @Override publicvoid handleMessage(Message msg) { super.handleMessage(msg); // 这里接收Handler发来的消息，运行在handler_thread线程中 //TODO... } }; //在主线程给Handler发送消息 handler.sendEmptyMessage(1) ; new Thread(new Runnable() { @Override publicvoid run() { //在子线程给Handler发送数据 handler.sendEmptyMessage(2) ; } }).start(); } @Override protected void onDestroy() { super.onDestroy(); //终止HandlerThread运行 myHandlerThread.quit() ; } ``` Q3：**用途** - 进行**串行**异步通信 - 构造`IntentService` - 方便实现在子线程（工作线程）中使用`Handler` Q4：原理： - 实际就是`HandlerThread.run()`里面封装了`Looper.prepare()`和`Looper.loop()`，以便能在子线程中使用`Handler` - 同时，`HandlerThread.getLooper()`中使用了`wait()和synchronized代码块`，当`Looper==NULL`的时候，锁住了当前的对象，那什么时候唤醒等待呢？当然是在初始化完该线程关联`Looper`对象的地方，也就是`run()` > 想了解源码的话，笔者推荐一篇文章：[浅析HandlerThread](https://blog.csdn.net/ta893115871/articlehttps://img.qb5200.com/download-x/details/55272187) #### 2.4.3 `IntentService` Q1:定义： `IntentService`是一个继承自`Service`的抽象类 Q2：优点： - 相比于线程：由于是服务，优先级比线程高，更不容易被系统杀死。因此较适合执行一些**高优先级**的后台任务 - 相比于普通`Service`：可**自动创建**子线程来执行任务，且任务执行完毕后**自动退出** Q3：使用方法 - 新建类并继承`IntentService`，重写`onHandleIntent()`，该方法： > - 运行在子线程，因此可以进行一些耗时操作 > - 作用：从`Intent`参数中区分具体的任务并执行这些任务 - 在配置文件中进行注册 - 在活动中利用`Intent`实现`IntentService`的启动： ```java Intent intent = new Intent(this, MyService.class); intent.putExtra("xxx",xxx); startService(intent);//启动服务 ``` > 注意：无需手动停止服务，`onHandleIntent()`执行结束之后，`IntentService`会自动停止。 Q4:工作原理 - 在`IntentService.onCreate()`里创建一个`Thread`对象即`HandlerThread`，利用其内部的`Looper`会实例化一个`ServiceHandler` - 任务请求的`Intent`会被封装到`Message`并通过`ServiceHandler`发送给`Looper`的`MessageQueue`，最终在`HandlerThread`中执行 - 在`ServiceHandler.handleMessage()`中会调用`IntentService.onHandleIntent()`，可在该方法中处理后台任务的逻辑,执行完毕后会调用`stopSelf()`，以实现自动停止  下面继续来研究下：将`Intent` 传递给服务 & 依次插入到工作队列中的流程  > 如果对`IntentService`的具体源码感兴趣的话，笔者推荐一篇文章：[Android多线程：IntentService用法&源码分析](https://blog.csdn.net/carson_ho/articlehttps://img.qb5200.com/download-x/details/53407806) ### 2.5 线程池 Q1：**优点** - **重用**线程池中的线程，避免线程的创建和销毁带来的性能消耗 - 有效控制线程池的最大并发数，避免大量的线程之间因互相抢占系统资源而导致阻塞现象 - 进行**线程管理**，提供定时/循环间隔执行等功能 Q2：**构造方法分析** > - 线程池的概念来源：Java中的`Executor`，它是一个接口 > - 线程池的真正实现：`ThreadPoolExecutor`，提供一系列参数来配置线程池 ```java //构造参数 public ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) { ``` - `corePoolSize`：核心线程数 > - 默认情况下，核心线程会在线程中一直存活 > > - 当设置`ThreadPoolExecutor`的`allowCoreThreadTimeOut`属性为 > > A.`true`：表示核心线程闲置超过超时时长，会被回收 > > B.`false`: 表示核心线程不会被回收，会在线程池中一直存活 - `maximumPoolSize`:最大线程数 > 当活动线程数达到这个数值后，后续的任务将会被阻塞 - `keepAliveTime`:非核心线程超时时间 > - 超过这个时长，闲置的非核心线程就会被回收 > - 当设置`ThreadPoolExecutor`的`allowCoreThreadTimeTout`属性为`true`时，`keepAliveTime`对核心线程同样有效 - `unit`：用于指定`keepAliveTime`参数的时间单位 > 单位有：`TimeUnit.MILLISECONDS`、`TimeUnit.SECONDS`、`TimeUnit.MINUTES`等； - `workQueue`：任务队列 > 通过线程池的`execute()`方法提交的`Runnable`对象会存储在这个参数中 - `threadFactory`：线程工厂，可创建新线程 > 一个接口，只有一个方法`Thread newThread(Runnable r)` - `handler`：在线程池无法执行新任务时进行调度 Q3：**`ThreadPoolExecutor`的默认工作策略**  ​ Q4：**线程池的分类** | 名称 | 含义 | 特点 | | ---------------------- | ------------------------------------------------------------ | ---------------------------------- | | `FixThreadPool` | 线程数量固定的线程池，所有线程都是**核心线程**，当线程空闲时**不会**被回收 | 能**快速**响应外界请求 | | `CachedThreadPool` | 线程数量不定的线程池（最大线程数为**Integer.MAX_VALUE**），只有**非核心线程**，空闲线程有超时机制，超时回收 | 适合于执行大量的**耗时较少**的任务 | | `ScheduledThreadPool` | 核心线程数量**固定**，非核心线程数量**不定** | **定时**任务和**固定**周期的任务 | | `SingleThreadExecutor` | 只有**一个核心线程**，可确保所有的任务都在同一个线程中**按顺序**执行 | 无需处理**线程同步**问题 | ## 三.再聊聊`AsyTask`的不足 > `AsyncTask` 看似十分美好，但实际上存在着非常多的**不足**，这些不足使得它逐渐退出了历史舞台，因此如今已经被 `RxJava`、`协程`等新兴框架所取代（PS:有机会希望能和大家一起探究下`RxJava`的源码） - 生命周期 > `AsyncTask` 没有与 `Activity`、`Fragment` 的生命周期绑定，即使 `Activity` 被销毁，它的 `doInBackground` 任务仍然会继续执行 - 取消任务 > `AsyncTask` 的 `cancel` 方法的参数 `mayInterruptIfRunning` 存在的意义不大，并且它无法保证任务一定能取消，只能尽快让任务取消（比如如果正在进行一些无法打断的操作时，任务就仍然会运行） - 内存泄漏 >- 由于它没有与 `Activity` 等生命周期进行绑定，因此它的生命周期仍然可能比 `Activity` 长 >- 如果将它作为 `Activity` 的非 `static` 内部类，则它会持有 `Activity` 的引用，导致 `Activity` 的内存无法释放。（PS:与 `Handler`的内存泄漏问题类似，参考文章：[进阶之路 | 奇妙的Handler之旅](https://juejin.im/post/5e61bf2de51d4526ea7f00bd)） - 并行/串行 > 由于 `AsyncTask` 的串行和并行执行在多个版本上都进行了修改，所以当多个 `AsyncTask` 依次执行时，它究竟是串行还是并行执行取决于用户手机的版本。具体修改如下： > > A.`Android 1.6` 之前：各个 `AsyncTask` 按串行的顺序进行执行 > > B.`Android 3.0` 之前：由于设计者认为串行执行效率太低，因此改为了并行执行，最多五个 `AsyncTask` 同时执行 > > C.`Android 3.0` 之后：由于之前的改动，很多应用出现了并发问题，因此引入 `SerialExecutor` 改回了串行执行，但对并行执行进行了支持 ------ 如果文章对您有一点帮助的话，希望您能点一下赞，您的点赞，是我前进的动力 本文参考链接： - 《Android 开发艺术探索》 - 《Android 进阶之光》 - [进阶之路 | 奇妙的Handler之旅](https://juejin.im/post/5e61bf2de51d4526ea7f00bd) - [Java线程中断的正确姿势](https://www.jianshu.com/p/264d4e1b76af) - [面试官最爱的volatile关键字](https://juejin.im/post/5a2b53b7f265da432a7b821c#heading-2) - [究竟什么是可重入锁？](https://blog.csdn.net/rickiyeat/articlehttps://img.qb5200.com/download-x/details/78314451) - [Android并发学习之阻塞队列](https://juejin.im/post/5b21ded3e51d4506bb3a84b6) - [Android AsyncTask完全解析，带你从源码的角度彻底理解](https://blog.csdn.net/guolin_blog/articlehttps://img.qb5200.com/download-x/details/11711405) - [浅析HandlerThread](https://blog.csdn.net/ta893115871/articlehttps://img.qb5200.com/download-x/details/55272187) - [Android多线程：IntentService用法&源码分析](https://blog.csdn.net/carson_ho/articlehttps://img.qb5200.com/download-x/details/53407806) - [要点提炼|开发艺术之线程](https://www.jianshu.com/p/ab77a2e83c52) - [AsyncTask 源码解析：Android 自带的异步任务工具](https://juejin.im/post/5e0dcae06fb9a047ef326bf1#heading-5)