全面详解Android实现多线程的几种方式（史上最全，最详细）
一、前言
Android多线程实现方式包括：
1、基础使用
- 继承Thread类
- 实现Runnable接口
- Handler
2、复合使用
- AsyncTask
- HandlerThread
- IntentService
3、高级使用
- 线程池（ThreadPool）
接下来对这几种实现多线程的方式进行全面 讲解。
二、基础使用
Android多线程实现的基础使用包括：
- 继承Thread类
- 实现Runnable接口
- Handler
接下来对各个进行分析。
1、继承Thread类
1.1 简介
1.2 使用详解
（1）使用步骤
（2） 具体使用
// 步骤1：创建线程类 （继承自Thread类）
class MyThread extends Thread{
// 步骤2：复写run（），内容 = 定义线程行为
@Override
public void run(){
... // 定义的线程行为
}
}
// 步骤3：创建线程对象，即 实例化线程类
MyThread mt=new MyThread(“线程名称”);
// 步骤4：通过 线程对象 控制线程的状态，如 运行、睡眠、挂起 / 停止
// 此处采用 start（）开启线程
mt.start();
（3） 简便使用：匿名类
很多情况下，开发者会选择一种更加方便的方法去创建线程：匿名类
// 步骤1：采用匿名类，直接 创建 线程类的实例
new Thread("线程名称") {
// 步骤2：复写run（），内容 = 定义线程行为
@Override
public void run() {
// 步骤3：通过 线程对象 控制线程的状态，如 运行、睡眠、挂起 / 停止
}.start();
上述两种使用方法本质相同，但是各有优劣势 & 不同的应用场景：
1.3 实例应用
实例
- 应用场景：创建两个线程-实现两个不同的耗时任务
- 实例说明：实现2个窗口同时卖火车票；每个窗口卖100张，但卖票速度不同：窗口1是1s/张，窗口2是3s/张
具体实现
main_activity.xml
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context="com.example.carson_ho.demoforthread_2.MainActivity">
//设置一个按钮以启动卖票
<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="点击开始卖票" />
</RelativeLayout>
MainActivity.java
package com.example.carson_ho.demoforthread_2;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
public class MainActivity extends AppCompatActivity {
//主布局中定义了一个按钮用以启动线程
Button button;
//步骤1:创建线程类,继承自Thread类
//因为这里需要有两个操作:一个窗口卖票速度是1s/张,一个窗口是3s/张
//所以需要创建两个Thread的子类
//第一个Thread子类实现一个窗口卖票速度是1s/张
private class MyThread1 extends Thread{
private int ticket = 100;//一个窗口有100张票
private String name; //窗口名, 也即是线程的名字
public MyThread1(String name){
this.name=name;
}
//在run方法里复写需要进行的操作:卖票速度是1s/张
@Override
public void run(){
while (ticket>0){
ticket--;
System.out.println(name + "卖掉了1张票，剩余票数为:"+ticket);
try {
Thread.sleep(1000);//卖票速度是1s一张
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//第二个Thread子类实现一个窗口卖票速度是3s/张
private class MyThread2 extends Thread{
private int ticket = 100;//一个窗口有100张票
private String name; //窗口名, 也即是线程的名字
public MyThread2(String name){
this.name=name;
}
//在run方法里复写需要进行的操作:卖票速度是3s/张
@Override
public void run(){
while (ticket>0){
ticket--;
System.out.println(name + "卖掉了1张票，剩余票数为:"+ticket);
try {
Thread.sleep(3000);//卖票速度是1s一张
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//Button按下时会开启一个新线程执行卖票
button = (Button) findViewById(R.id.button);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//步骤2:创建线程类的实例
//创建二个线程，模拟二个窗口卖票
MyThread1 mt1 = new MyThread1("窗口1");
MyThread2 mt2 = new MyThread2("窗口2");
//步骤3：调用start()方法开启线程
//启动二个线程，也即是窗口，开始卖票
mt1.start();
mt2.start();
}
});
}
}
测试结果
由于卖票速度不同，所以窗口1卖3张时，窗口2才卖1张。
1.4 与“实现Runnable接口”对比
在Java中，继承 Thread类和实现Runnable接口是实现多线程最常用的2种方法
今天我们就来对比下这两种方法
2、实现Runnable接口
2.1 简介
2.2 使用详情
（1）使用步骤
特别注意：
- Java中真正能创建新线程的只有Thread类对象
- 通过实现Runnable的方式，最终还是通过Thread类对象来创建线程
- 所以对于 实现了Runnable接口的类，称为 线程辅助类；Thread类才是真正的线程类
（2） 具体使用
// 步骤1：创建线程辅助类，实现Runnable接口
class MyThread implements Runnable{
....
@Override
// 步骤2：复写run（），定义线程行为
public void run(){
}
}
// 步骤3：创建线程辅助对象，即 实例化 线程辅助类
MyThread mt=new MyThread();
// 步骤4：创建线程对象，即 实例化线程类；线程类 = Thread类；
// 创建时通过Thread类的构造函数传入线程辅助类对象
// 原因：Runnable接口并没有任何对线程的支持，我们必须创建线程类（Thread类）的实例，从Thread类的一个实例内部运行
Thread td=new Thread(mt);
// 步骤5：通过 线程对象 控制线程的状态，如 运行、睡眠、挂起 / 停止
// 当调用start（）方法时，线程对象会自动回调线程辅助类对象的run（），从而实现线程操作
td.start();
（3） 简便使用：匿名类
很多情况下，开发者会选择一种更加方便的方法去创建线程：匿名类
// 步骤1：通过匿名类 直接 创建线程辅助对象，即 实例化 线程辅助类
Runnable mt = new Runnable() {
// 步骤2：复写run（），定义线程行为
@Override
public void run() {
}
};
// 步骤3：创建线程对象，即 实例化线程类；线程类 = Thread类；
Thread mt1 = new Thread(mt, "窗口1");
// 步骤4：通过 线程对象 控制线程的状态，如 运行、睡眠、挂起 / 停止
mt1.start();
以上2种方法本质相同，但是各有优劣势 & 不同的应用场景：
2.3 实例应用
实例
- 应用场景：创建两个线程-实现一个耗时任务
- 实例说明：实现2个窗口同时卖火车票；两个窗口一共卖100张，卖票速度均为1s/张
具体实现
main_activity.xml
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context="com.example.carson_ho.demoforrunnable3.MainActivity">
//设置按钮用以启动线程
<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="点击开始卖票" />
</RelativeLayout>
MainActivity.java
package com.example.carson_ho.demoforrunnable3;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
public class MainActivity extends AppCompatActivity {
//主布局中定义了一个按钮用以启动线程
Button button;
//步骤1:创建线程类，实现Runnable接口
private class MyThread1 implements Runnable{
private int ticket = 100;//两个窗口一共要卖100张票
//在run方法里复写需要进行的操作:卖票速度1s/张
@Override
public void run(){
while (ticket>0){
ticket--;
System.out.println(Thread.currentThread().getName() + "卖掉了1张票，剩余票数为:"+ticket);
try {
Thread.sleep(1000);//卖票速度是1s一张
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//Button按下时会开启一个新线程执行卖票
button = (Button) findViewById(R.id.button);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//步骤2:创建线程类的实例
//因为是两个窗口共卖100张票,即共用资源
//所以只实例化一个实现了Runnable接口的类
MyThread1 mt = new MyThread1();
//因为要创建二个线程，模拟二个窗口卖票
Thread mt11 = new Thread(mt, "窗口1");
Thread mt12 = new Thread(mt, "窗口2");
//步骤3：调用start()方法开启线程
//启动二个线程，也即是窗口，开始卖票
mt11.start();
mt12.start();
}
});
}
}
测试结果
实现了两个窗口一起卖100张票的目的
3、 Handler
3.1 作用
在多线程的应用场景中，将工作线程中需更新UI的操作信息 传递到 UI主线程，从而实现 工作线程对UI的更新处理，最终实现异步消息的处理
3.2 意义
问：为什么要用 Handler消息传递机制
答：多个线程并发更新UI的同时 保证线程安全
具体描述如下：
3.4 相关概念
关于 Handler 异步通信机制中的相关概念如下：
在下面的讲解中，我将直接使用英文名讲解，即 Handler、Message、Message Queue、Looper，希望大家先熟悉相关概念
3.5 使用方式
Handler的使用方式 因发送消息到消息队列的方式不同而不同
共分为2种：使用Handler.sendMessage（）、使用Handler.post（）
- 方式1：使用 Handler.sendMessage（）
在该使用方式中，又分为2种：新建Handler子类（内部类）、匿名 Handler子类
但本质相同，即 继承了Handler类 & 创建了子类
/**
* 方式1：新建Handler子类（内部类）
*/
// 步骤1：自定义Handler子类（继承Handler类） & 复写handleMessage（）方法
class mHandler extends Handler {
// 通过复写handlerMessage() 从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
...// 需执行的UI操作
}
}
// 步骤2：在主线程中创建Handler实例
private Handler mhandler = new mHandler();
// 步骤3：创建所需的消息对象
Message msg = Message.obtain(); // 实例化消息对象
msg.what = 1; // 消息标识
msg.obj = "AA"; // 消息内容存放
// 步骤4：在工作线程中 通过Handler发送消息到消息队列中
// 可通过sendMessage（） / post（）
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
mHandler.sendMessage(msg);
// 步骤5：开启工作线程（同时启动了Handler）
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
/**
* 方式2：匿名内部类
*/
// 步骤1：在主线程中 通过匿名内部类 创建Handler类对象
private Handler mhandler = new Handler(){
// 通过复写handlerMessage()从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
...// 需执行的UI操作
}
};
// 步骤2：创建消息对象
Message msg = Message.obtain(); // 实例化消息对象
msg.what = 1; // 消息标识
msg.obj = "AA"; // 消息内容存放
// 步骤3：在工作线程中 通过Handler发送消息到消息队列中
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
mHandler.sendMessage(msg);
// 步骤4：开启工作线程（同时启动了Handler）
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
- 方式2：使用Handler.post（）
// 步骤1：在主线程中创建Handler实例
private Handler mhandler = new mHandler();
// 步骤2：在工作线程中 发送消息到消息队列中 & 指定操作UI内容
// 需传入1个Runnable对象
mHandler.post(new Runnable() {
@Override
public void run() {
... // 需执行的UI操作
}
});
// 步骤3：开启工作线程（同时启动了Handler）
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
3.6 实例讲解
本文将用实例逐个讲解 Handler的用法
注：
- 由于Handler的作用 = 将工作线程需操作UI的消息 传递 到主线程，使得主线程可根据工作线程的需求
- 更新UI，从而避免线程操作不安全的问题 故下文的实例 = 1个简单 “更新UI操作” 的案例
- 主布局文件相同 = 1个用于展示的TextView，具体如下：
布局代码：activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
tools:context="com.example.carson_ho.handler_learning.MainActivity">
<TextView
android:id="@+id/show"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="" />
</RelativeLayout>
(1) 使用 Handler.sendMessage（）
方式1：新建Handler子类（内部类）
- 具体使用
public class MainActivity extends AppCompatActivity {
public TextView mTextView;
public Handler mHandler;
// 步骤1：（自定义）新创建Handler子类(继承Handler类) & 复写handleMessage（）方法
class Mhandler extends Handler {
// 通过复写handlerMessage() 从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
// 根据不同线程发送过来的消息，执行不同的UI操作
// 根据 Message对象的what属性 标识不同的消息
switch (msg.what) {
case 1:
mTextView.setText("执行了线程1的UI操作");
break;
case 2:
mTextView.setText("执行了线程2的UI操作");
break;
}
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mTextView = (TextView) findViewById(R.id.show);
// 步骤2：在主线程中创建Handler实例
mHandler = new Mhandler();
// 采用继承Thread类实现多线程演示
new Thread() {
@Override
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 步骤3：创建所需的消息对象
Message msg = Message.obtain();
msg.what = 1; // 消息标识
msg.obj = "A"; // 消息内存存放
// 步骤4：在工作线程中 通过Handler发送消息到消息队列中
mHandler.sendMessage(msg);
}
}.start();
// 步骤5：开启工作线程（同时启动了Handler）
// 此处用2个工作线程展示
new Thread() {
@Override
public void run() {
try {
Thread.sleep(6000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 通过sendMessage（）发送
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 2; //消息的标识
msg.obj = "B"; // 消息的存放
// b. 通过Handler发送消息到其绑定的消息队列
mHandler.sendMessage(msg);
}
}.start();
}
}
方式2：匿名内部类
- 具体使用
public class MainActivity extends AppCompatActivity {
public TextView mTextView;
public Handler mHandler;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mTextView = (TextView) findViewById(R.id.show);
// 步骤1：在主线程中 通过匿名内部类 创建Handler类对象
mHandler = new Handler(){
// 通过复写handlerMessage()从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
// 根据不同线程发送过来的消息，执行不同的UI操作
switch (msg.what) {
case 1:
mTextView.setText("执行了线程1的UI操作");
break;
case 2:
mTextView.setText("执行了线程2的UI操作");
break;
}
}
};
// 采用继承Thread类实现多线程演示
new Thread() {
@Override
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 步骤3：创建所需的消息对象
Message msg = Message.obtain();
msg.what = 1; // 消息标识
msg.obj = "A"; // 消息内存存放
// 步骤4：在工作线程中 通过Handler发送消息到消息队列中
mHandler.sendMessage(msg);
}
}.start();
// 步骤5：开启工作线程（同时启动了Handler）
// 此处用2个工作线程展示
new Thread() {
@Override
public void run() {
try {
Thread.sleep(6000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 通过sendMessage（）发送
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 2; //消息的标识
msg.obj = "B"; // 消息的存放
// b. 通过Handler发送消息到其绑定的消息队列
mHandler.sendMessage(msg);
}
}.start();
}
}
(2) 使用 Handler.post（）
- 具体使用
public class MainActivity extends AppCompatActivity {
public TextView mTextView;
public Handler mHandler;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mTextView = (TextView) findViewById(R.id.show);
// 步骤1：在主线程中创建Handler实例
mHandler = new Handler();
// 步骤2：在工作线程中 发送消息到消息队列中 & 指定操作UI内容
new Thread() {
@Override
public void run() {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 通过psot（）发送，需传入1个Runnable对象
mHandler.post(new Runnable() {
@Override
public void run() {
// 指定操作UI内容
mTextView.setText("执行了线程1的UI操作");
}
});
}
}.start();
// 步骤3：开启工作线程（同时启动了Handler）
// 此处用2个工作线程展示
new Thread() {
@Override
public void run() {
try {
Thread.sleep(6000);
} catch (InterruptedException e) {
e.printStackTrace();
}
mHandler.post(new Runnable() {
@Override
public void run() {
mTextView.setText("执行了线程2的UI操作");
}
});
}
}.start();
}
}
3.7 工作原理 解析
（1）工作流程解析
Handler机制的工作流程主要包括4个步骤：
异步通信准备
消息发送
消息循环
消息处理
具体如下图：
（2）工作流程图
（3） 示意图
（4） 特别注意
线程（Thread）、循环器（Looper）、处理者（Handler）之间的对应关系如下：
- 1个线程（Thread）只能绑定 1个循环器（Looper），但可以有多个处理者（Handler）
- 1个循环器（Looper） 可绑定多个处理者（Handler）
- 1个处理者（Handler） 只能绑定1个1个循环器（Looper）
3.8 Handler机制的核心类
在源码分析前，先来了解Handler机制中的核心类
（1） 类说明
Handler机制 中有3个重要的类：
- 处理器 类（Handler）
- 消息队列 类（MessageQueue）
- 循环器 类（Looper）
（2） 类图
（3） 具体介绍
3.9 源码分析
下面的源码分析将根据 Handler的使用步骤进行
Handler使用方式 因发送消息到消息队列的方式不同而不同，共分为2种：使用Handler.sendMessage（）、使用Handler.post（）
下面的源码分析将依据上述2种使用方式进行
方式1：使用 Handler.sendMessage（）
- 使用步骤
/**
* 此处以 匿名内部类 的使用方式为例
*/
// 步骤1：在主线程中 通过匿名内部类 创建Handler类对象
private Handler mhandler = new Handler(){
// 通过复写handlerMessage()从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
...// 需执行的UI操作
}
};
// 步骤2：创建消息对象
Message msg = Message.obtain(); // 实例化消息对象
msg.what = 1; // 消息标识
msg.obj = "AA"; // 消息内容存放
// 步骤3：在工作线程中 通过Handler发送消息到消息队列中
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
mHandler.sendMessage(msg);
// 步骤4：开启工作线程（同时启动了Handler）
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
- 源码分析
下面，我将根据上述每个步骤进行源码分析
步骤1：在主线程中 通过匿名内部类 创建Handler类对象
/**
* 具体使用
*/
private Handler mhandler = new Handler(){
// 通过复写handlerMessage()从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
...// 需执行的UI操作
}
};
/**
* 源码分析：Handler的构造方法
* 作用：初始化Handler对象 & 绑定线程
* 注：
* a. Handler需绑定 线程才能使用；绑定后，Handler的消息处理会在绑定的线程中执行
* b. 绑定方式 = 先指定Looper对象，从而绑定了 Looper对象所绑定的线程（因为Looper对象本已绑定了对应线程）
* c. 即：指定了Handler对象的 Looper对象 = 绑定到了Looper对象所在的线程
*/
public Handler() {
this(null, false);
// ->>分析1
}
/**
* 分析1：this(null, false) = Handler（null，false）
*/
public Handler(Callback callback, boolean async) {
...// 仅贴出关键代码
// 1. 指定Looper对象
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
// Looper.myLooper()作用：获取当前线程的Looper对象；若线程无Looper对象则抛出异常
// 即 ：若线程中无创建Looper对象，则也无法创建Handler对象
// 故 若需在子线程中创建Handler对象，则需先创建Looper对象
// 注：可通过Loop.getMainLooper()可以获得当前进程的主线程的Looper对象
// 2. 绑定消息队列对象（MessageQueue）
mQueue = mLooper.mQueue;
// 获取该Looper对象中保存的消息队列对象（MessageQueue）
// 至此，保证了handler对象 关联上 Looper对象中MessageQueue
}
从上面可看出：
-
当创建Handler对象时，则通过 构造方法 自动关联当前线程的Looper对象 & 对应的消息队列对象（MessageQueue），从而 自动绑定了 实现创建Handler对象操作的线程
-
那么，当前线程的Looper对象 & 对应的消息队列对象（MessageQueue） 是什么时候创建的呢？
在上述使用步骤中，并无 创建Looper对象 & 对应的消息队列对象（MessageQueue）这1步
步骤1前的隐式操作1：创建循环器对象（Looper） & 消息队列对象（MessageQueue）
-
步骤介绍
-
源码分析
/**
* 源码分析1：Looper.prepare()
* 作用：为当前线程（子线程） 创建1个循环器对象（Looper），同时也生成了1个消息队列对象（MessageQueue）
* 注：需在子线程中手动调用该方法
*/
public static final void prepare() {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
// 1. 判断sThreadLocal是否为null，否则抛出异常
//即 Looper.prepare()方法不能被调用两次 = 1个线程中只能对应1个Looper实例
// 注：sThreadLocal = 1个ThreadLocal对象，用于存储线程的变量
sThreadLocal.set(new Looper(true));
// 2. 若为初次Looper.prepare()，则创建Looper对象 & 存放在ThreadLocal变量中
// 注：Looper对象是存放在Thread线程里的
// 源码分析Looper的构造方法->>分析a
}
/**
* 分析a：Looper的构造方法
**/
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
// 1. 创建1个消息队列对象（MessageQueue）
// 即 当创建1个Looper实例时，会自动创建一个与之配对的消息队列对象（MessageQueue）
mRun = true;
mThread = Thread.currentThread();
}
/**
* 源码分析2：Looper.prepareMainLooper()
* 作用：为 主线程（UI线程） 创建1个循环器对象（Looper），同时也生成了1个消息队列对象（MessageQueue）
* 注：该方法在主线程（UI线程）创建时自动调用，即 主线程的Looper对象自动生成，不需手动生成
*/
// 在Android应用进程启动时，会默认创建1个主线程（ActivityThread，也叫UI线程）
// 创建时，会自动调用ActivityThread的1个静态的main（）方法 = 应用程序的入口
// main（）内则会调用Looper.prepareMainLooper()为主线程生成1个Looper对象
/**
* 源码分析：main（）
**/
public static void main(String[] args) {
... // 仅贴出关键代码
Looper.prepareMainLooper();
// 1. 为主线程创建1个Looper对象，同时生成1个消息队列对象（MessageQueue）
// 方法逻辑类似Looper.prepare()
// 注：prepare()：为子线程中创建1个Looper对象
ActivityThread thread = new ActivityThread();
// 2. 创建主线程
Looper.loop();
// 3. 自动开启 消息循环 ->>下面将详细分析
}
总结：
- 创建主线程时，会自动调用ActivityThread的1个静态的main（）；而main（）内则会调用Looper.prepareMainLooper()为主线程生成1个Looper对象，同时也会生成其对应的MessageQueue对象
（1）即 主线程的Looper对象自动生成，不需手动生成；而子线程的Looper对象则需手动通过Looper.prepare()创建
（2）在子线程若不手动创建Looper对象 则无法生成Handler对象
-
根据Handler的作用（在主线程更新UI），故Handler实例的创建场景 主要在主线程
-
生成Looper & MessageQueue对象后，则会自动进入消息循环：Looper.loop（），即又是另外一个隐式操作。
步骤1前的隐式操作2：消息循环
此处主要分析的是Looper类中的loop（）方法
/**
* 源码分析： Looper.loop()
* 作用：消息循环，即从消息队列中获取消息、分发消息到Handler
* 特别注意：
* a. 主线程的消息循环不允许退出，即无限循环
* b. 子线程的消息循环允许退出：调用消息队列MessageQueue的quit（）
*/
public static void loop() {
...// 仅贴出关键代码
// 1. 获取当前Looper的消息队列
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
// myLooper()作用：返回sThreadLocal存储的Looper实例；若me为null 则抛出异常
// 即loop（）执行前必须执行prepare（），从而创建1个Looper实例
final MessageQueue queue = me.mQueue;
// 获取Looper实例中的消息队列对象（MessageQueue）
// 2. 消息循环（通过for循环）
for (;;) {
// 2.1 从消息队列中取出消息
Message msg = queue.next();
if (msg == null) {
return;
}
// next()：取出消息队列里的消息
// 若取出的消息为空，则线程阻塞
// ->> 分析1
// 2.2 派发消息到对应的Handler
msg.target.dispatchMessage(msg);
// 把消息Message派发给消息对象msg的target属性
// target属性实际是1个handler对象
// ->>分析2
// 3. 释放消息占据的资源
msg.recycle();
}
}
/**
* 分析1：queue.next()
* 定义：属于消息队列类（MessageQueue）中的方法
* 作用：出队消息，即从 消息队列中 移出该消息
*/
Message next() {
...// 仅贴出关键代码
// 该参数用于确定消息队列中是否还有消息
// 从而决定消息队列应处于出队消息状态 or 等待状态
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
// nativePollOnce方法在native层，若是nextPollTimeoutMillis为-1，此时消息队列处于等待状态
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
// 出队消息，即 从消息队列中取出消息：按创建Message对象的时间顺序
if (msg != null) {
if (now < msg.when) {
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// 取出了消息
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
return msg;
}
} else {
// 若 消息队列中已无消息，则将nextPollTimeoutMillis参数设为-1
// 下次循环时，消息队列则处于等待状态
nextPollTimeoutMillis = -1;
}
......
}
.....
}
}// 回到分析原处
/**
* 分析2：dispatchMessage(msg)
* 定义：属于处理者类（Handler）中的方法
* 作用：派发消息到对应的Handler实例 & 根据传入的msg作出对应的操作
*/
public void dispatchMessage(Message msg) {
// 1. 若msg.callback属性不为空，则代表使用了post（Runnable r）发送消息
// 则执行handleCallback(msg)，即回调Runnable对象里复写的run（）
// 上述结论会在讲解使用“post（Runnable r）”方式时讲解
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
// 2. 若msg.callback属性为空，则代表使用了sendMessage（Message msg）发送消息（即此处需讨论的）
// 则执行handleMessage(msg)，即回调复写的handleMessage(msg) ->> 分析3
handleMessage(msg);
}
}
/**
* 分析3：handleMessage(msg)
* 注：该方法 = 空方法，在创建Handler实例时复写 = 自定义消息处理方式
**/
public void handleMessage(Message msg) {
... // 创建Handler实例时复写
}
总结：
- 消息循环的操作 = 消息出队 + 分发给对应的Handler实例
- 分发给对应的Handler的过程：根据出队消息的归属者通过dispatchMessage(msg)进行分发，最终回调复写的handleMessage(Message msg)，从而实现 消息处理 的操作
- 特别注意：在进行消息分发时（dispatchMessage(msg)），会进行1次发送方式的判断：
（1）若msg.callback属性不为空，则代表使用了post（Runnable r）发送消息，则直接回调Runnable对象里复写的run（）
（2）若msg.callback属性为空，则代表使用了sendMessage（Message msg）发送消息，则回调复写的handleMessage(msg)
至此，关于步骤1的源码分析讲解完毕。总结如下
步骤2：创建消息对象
/**
* 具体使用
*/
Message msg = Message.obtain(); // 实例化消息对象
msg.what = 1; // 消息标识
msg.obj = "AA"; // 消息内容存放
/**
* 源码分析：Message.obtain()
* 作用：创建消息对象
* 注：创建Message对象可用关键字new 或 Message.obtain()
*/
public static Message obtain() {
// Message内部维护了1个Message池，用于Message消息对象的复用
// 使用obtain（）则是直接从池内获取
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--;
return m;
}
// 建议：使用obtain（）”创建“消息对象，避免每次都使用new重新分配内存
}
// 若池内无消息对象可复用，则还是用关键字new创建
return new Message();
}
总结
步骤3：在工作线程中 发送消息到消息队列中
多线程的实现方式：AsyncTask、继承Thread类、实现Runnable
/**
* 具体使用
*/
mHandler.sendMessage(msg);
/**
* 源码分析：mHandler.sendMessage(msg)
* 定义：属于处理器类（Handler）的方法
* 作用：将消息 发送 到消息队列中（Message ->> MessageQueue）
*/
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
// ->>分析1
}
/**
* 分析1：sendMessageDelayed(msg, 0)
**/
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
// ->> 分析2
}
/**
* 分析2：sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis)
**/
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
// 1. 获取对应的消息队列对象（MessageQueue）
MessageQueue queue = mQueue;
// 2. 调用了enqueueMessage方法 ->>分析3
return enqueueMessage(queue, msg, uptimeMillis);
}
/**
* 分析3：enqueueMessage(queue, msg, uptimeMillis)
**/
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
// 1. 将msg.target赋值为this
// 即 ：把 当前的Handler实例对象作为msg的target属性
msg.target = this;
// 请回忆起上面说的Looper的loop()中消息循环时，会从消息队列中取出每个消息msg，然后执行msg.target.dispatchMessage(msg)去处理消息
// 实际上则是将该消息派发给对应的Handler实例
// 2. 调用消息队列的enqueueMessage（）
// 即：Handler发送的消息，最终是保存到消息队列->>分析4
return queue.enqueueMessage(msg, uptimeMillis）;
}
/**
* 分析4：queue.enqueueMessage(msg, uptimeMillis）
* 定义：属于消息队列类（MessageQueue）的方法
* 作用：入队，即 将消息 根据时间 放入到消息队列中（Message ->> MessageQueue）
* 采用单链表实现：提高插入消息、删除消息的效率
*/
boolean enqueueMessage(Message msg, long when) {
...// 仅贴出关键代码
synchronized (this) {
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
// 判断消息队列里有无消息
// a. 若无，则将当前插入的消息 作为队头 & 若此时消息队列处于等待状态，则唤醒
if (p == null || when == 0 || when < p.when) {
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
// b. 判断消息队列里有消息，则根据 消息（Message）创建的时间 插入到队列中
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p;
prev.next = msg;
}
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
// 之后，随着Looper对象的无限消息循环
// 不断从消息队列中取出Handler发送的消息 & 分发到对应Handler
// 最终回调Handler.handleMessage()处理消息
总结
Handler发送消息的本质 = 为该消息定义target属性（即本身实例对象） & 将消息入队到绑定线程的消息队列中。具体如下：
至此，关于使用 Handler.sendMessage（）的源码解析完毕
总结
-
根据操作步骤的源码分析总结
-
工作流程总结
下面，将顺着文章：工作流程再理一次
方式2：使用 Handler.post（） -
使用步骤
// 步骤1：在主线程中创建Handler实例
private Handler mhandler = new mHandler();
// 步骤2：在工作线程中 发送消息到消息队列中 & 指定操作UI内容
// 需传入1个Runnable对象
mHandler.post(new Runnable() {
@Override
public void run() {
... // 需执行的UI操作
}
});
// 步骤3：开启工作线程（同时启动了Handler）
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
- 源码分析
下面，我将根据上述每个步骤进行源码分析
实际上，该方式与方式1中的Handler.sendMessage（）工作原理相同、源码分析类似，下面将主要讲解不同之处
步骤1：在主线程中创建Handler实例
/**
* 具体使用
*/
private Handler mhandler = new Handler()；
// 与方式1的使用不同：此处无复写Handler.handleMessage()
/**
* 源码分析：Handler的构造方法
* 作用：
* a. 在此之前，主线程创建时隐式创建Looper对象、MessageQueue对象
* b. 初始化Handler对象、绑定线程 & 进入消息循环
* 此处的源码分析类似方式1，此处不作过多描述
*/
步骤2：在工作线程中 发送消息到消息队列中
/**
* 具体使用
* 需传入1个Runnable对象、复写run()从而指定UI操作
*/
mHandler.post(new Runnable() {
@Override
public void run() {
... // 需执行的UI操作
}
});
/**
* 源码分析：Handler.post（Runnable r）
* 定义：属于处理者类（Handler）中的方法
* 作用：定义UI操作、将Runnable对象封装成消息对象 & 发送 到消息队列中（Message ->> MessageQueue）
* 注：
* a. 相比sendMessage()，post（）最大的不同在于，更新的UI操作可直接在重写的run（）中定义
* b. 实际上，Runnable并无创建新线程，而是发送 消息 到消息队列中
*/
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
// getPostMessage(r) 的源码分析->>分析1
// sendMessageDelayed（）的源码分析 ->>分析2
}
/**
* 分析1：getPostMessage(r)
* 作用：将传入的Runable对象封装成1个消息对象
**/
private static Message getPostMessage(Runnable r) {
// 1. 创建1个消息对象（Message）
Message m = Message.obtain();
// 注：创建Message对象可用关键字new 或 Message.obtain()
// 建议：使用Message.obtain()创建，
// 原因：因为Message内部维护了1个Message池，用于Message的复用，使用obtain（）直接从池内获取，从而避免使用new重新分配内存
// 2. 将 Runable对象 赋值给消息对象（message）的callback属性
m.callback = r;
// 3. 返回该消息对象
return m;
} // 回到调用原处
/**
* 分析2：sendMessageDelayed(msg, 0)
* 作用：实际上，从此处开始，则类似方式1 = 将消息入队到消息队列，
* 即 最终是调用MessageQueue.enqueueMessage（）
**/
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
// 请看分析3
}
/**
* 分析3：sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis)
**/
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
// 1. 获取对应的消息队列对象（MessageQueue）
MessageQueue queue = mQueue;
// 2. 调用了enqueueMessage方法 ->>分析3
return enqueueMessage(queue, msg, uptimeMillis);
}
/**
* 分析4：enqueueMessage(queue, msg, uptimeMillis)
**/
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
// 1. 将msg.target赋值为this
// 即 ：把 当前的Handler实例对象作为msg的target属性
msg.target = this;
// 请回忆起上面说的Looper的loop()中消息循环时，会从消息队列中取出每个消息msg，然后执行msg.target.dispatchMessage(msg)去处理消息
// 实际上则是将该消息派发给对应的Handler实例
// 2. 调用消息队列的enqueueMessage（）
// 即：Handler发送的消息，最终是保存到消息队列
return queue.enqueueMessage(msg, uptimeMillis）;
}
// 注：实际上从分析2开始，源码 与 sendMessage（Message msg）发送方式相同
从上面的分析可看出：
- 消息对象的创建 = 内部 根据Runnable对象而封装
- 发送到消息队列的逻辑 = 方式1中sendMessage（Message msg）
下面，我们重新回到步骤1前的隐式操作2：消息循环，即Looper类中的loop（）方法
/**
* 源码分析： Looper.loop()
* 作用：消息循环，即从消息队列中获取消息、分发消息到Handler
* 特别注意：
* a. 主线程的消息循环不允许退出，即无限循环
* b. 子线程的消息循环允许退出：调用消息队列MessageQueue的quit（）
*/
public static void loop() {
...// 仅贴出关键代码
// 1. 获取当前Looper的消息队列
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
// myLooper()作用：返回sThreadLocal存储的Looper实例；若me为null 则抛出异常
// 即loop（）执行前必须执行prepare（），从而创建1个Looper实例
final MessageQueue queue = me.mQueue;
// 获取Looper实例中的消息队列对象（MessageQueue）
// 2. 消息循环（通过for循环）
for (;;) {
// 2.1 从消息队列中取出消息
Message msg = queue.next();
if (msg == null) {
return;
}
// next()：取出消息队列里的消息
// 若取出的消息为空，则线程阻塞
// 2.2 派发消息到对应的Handler
msg.target.dispatchMessage(msg);
// 把消息Message派发给消息对象msg的target属性
// target属性实际是1个handler对象
// ->>分析1
// 3. 释放消息占据的资源
msg.recycle();
}
}
/**
* 分析1：dispatchMessage(msg)
* 定义：属于处理者类（Handler）中的方法
* 作用：派发消息到对应的Handler实例 & 根据传入的msg作出对应的操作
*/
public void dispatchMessage(Message msg) {
// 1. 若msg.callback属性不为空，则代表使用了post（Runnable r）发送消息（即此处需讨论的）
// 则执行handleCallback(msg)，即回调Runnable对象里复写的run（）->> 分析2
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
// 2. 若msg.callback属性为空，则代表使用了sendMessage（Message msg）发送消息（即此处需讨论的）
// 则执行handleMessage(msg)，即回调复写的handleMessage(msg)
handleMessage(msg);
}
}
/**
* 分析2：handleCallback(msg)
**/
private static void handleCallback(Message message) {
message.callback.run();
// Message对象的callback属性 = 传入的Runnable对象
// 即回调Runnable对象里复写的run（）
}
至此，你应该明白使用 Handler.post（）的工作流程：与方式1（Handler.sendMessage（））类似，区别在于：
- 不需外部创建消息对象，而是内部根据传入的Runnable对象 封装消息对象
- 回调的消息处理方法是：复写Runnable对象的run（）
二者的具体异同如下：
至此，关于使用 Handler.post（）的源码解析完毕
总结
- 根据操作步骤的源码分析总结
- 工作流程总结
下面，将顺着文章：工作流程再理一次
3.10 特别注意：Handle引起的内存泄漏
1. 问题描述
Handler的一般用法 = 新建Handler子类（内部类） 、匿名Handler内部类
/**
* 方式1：新建Handler子类（内部类）
*/
public class MainActivity extends AppCompatActivity {
public static final String TAG = "carson：";
private Handler showhandler;
// 主线程创建时便自动创建Looper & 对应的MessageQueue
// 之后执行Loop()进入消息循环
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//1. 实例化自定义的Handler类对象->>分析1
//注：此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueue
showhandler = new FHandler();
// 2. 启动子线程1
new Thread() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 1;// 消息标识
msg.obj = "AA";// 消息存放
// b. 传入主线程的Handler & 向其MessageQueue发送消息
showhandler.sendMessage(msg);
}
}.start();
// 3. 启动子线程2
new Thread() {
@Override
public void run() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 2;// 消息标识
msg.obj = "BB";// 消息存放
// b. 传入主线程的Handler & 向其MessageQueue发送消息
showhandler.sendMessage(msg);
}
}.start();
}
// 分析1：自定义Handler子类
class FHandler extends Handler {
// 通过复写handlerMessage() 从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
Log.d(TAG, "收到线程1的消息");
break;
case 2:
Log.d(TAG, " 收到线程2的消息");
break;
}
}
}
}
/**
* 方式2：匿名Handler内部类
*/
public class MainActivity extends AppCompatActivity {
public static final String TAG = "carson：";
private Handler showhandler;
// 主线程创建时便自动创建Looper & 对应的MessageQueue
// 之后执行Loop()进入消息循环
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//1. 通过匿名内部类实例化的Handler类对象
//注：此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueue
showhandler = new Handler(){
// 通过复写handlerMessage()从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
Log.d(TAG, "收到线程1的消息");
break;
case 2:
Log.d(TAG, " 收到线程2的消息");
break;
}
}
};
// 2. 启动子线程1
new Thread() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 1;// 消息标识
msg.obj = "AA";// 消息存放
// b. 传入主线程的Handler & 向其MessageQueue发送消息
showhandler.sendMessage(msg);
}
}.start();
// 3. 启动子线程2
new Thread() {
@Override
public void run() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 2;// 消息标识
msg.obj = "BB";// 消息存放
// b. 传入主线程的Handler & 向其MessageQueue发送消息
showhandler.sendMessage(msg);
}
}.start();
}
}
测试结果
示意图
- 上述例子虽可运行成功，但代码会出现严重警告：
- 警告的原因 = 该Handler类由于无设置为 静态类，从而导致了内存泄露
- 最终的内存泄露发生在Handler类的外部类：MainActivity类
示意图
那么，该Handler在无设置为静态类时，为什么会造成内存泄露呢？
2. 原因讲解
2.1 储备知识
- 主线程的Looper对象的生命周期 = 该应用程序的生命周期
- 在Java中，非静态内部类 & 匿名内部类都默认持有 外部类的引用
2.2 泄露原因描述
从上述示例代码可知：
-
上述的Handler实例的消息队列有2个分别来自线程1、2的消息（分别 为延迟1s、6s）
-
在Handler消息队列 还有未处理的消息 / 正在处理消息时，消息队列中的Message持有Handler实例的引用
-
由于Handler = 非静态内部类 / 匿名内部类（2种使用方式），故又默认持有外部类的引用（即MainActivity实例），引用关系如下图
上述的引用关系会一直保持，直到Handler消息队列中的所有消息被处理完毕
-
在Handler消息队列 还有未处理的消息 / 正在处理消息时，此时若需销毁外部类MainActivity，但由于上述引用关系，垃圾回收器（GC）无法回收MainActivity，从而造成内存泄漏。如下图：
2.3 总结 -
当Handler消息队列 还有未处理的消息 / 正在处理消息时，存在引用关系： “未被处理 / 正处理的消息 -> Handler实例 -> 外部类”
-
若出现 Handler的生命周期 > 外部类的生命周期 时（即 Handler消息队列 还有未处理的消息 / 正在处理消息 而 外部类需销毁时），将使得外部类无法被垃圾回收器（GC）回收，从而造成 内存泄露
- 解决方案
从上面可看出，造成内存泄露的原因有2个关键条件：
- 存在“未被处理 / 正处理的消息 -> Handler实例 -> 外部类” 的引用关系
- Handler的生命周期 > 外部类的生命周期
- 即 Handler消息队列 还有未处理的消息 / 正在处理消息 而 外部类需销毁
解决方案的思路 = 使得上述任1条件不成立 即可。
解决方案1：静态内部类+弱引用
-
原理
静态内部类 不默认持有外部类的引用，从而使得 “未被处理 / 正处理的消息 -> Handler实例 -> 外部类” 的引用关系 的引用关系 不复存在。 -
具体方案
将Handler的子类设置成 静态内部类
- 同时，还可加上 使用WeakReference弱引用持有Activity实例
- 原因：弱引用的对象拥有短暂的生命周期。在垃圾回收器线程扫描时，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存
- 解决代码
public class MainActivity extends AppCompatActivity {
public static final String TAG = "carson：";
private Handler showhandler;
// 主线程创建时便自动创建Looper & 对应的MessageQueue
// 之后执行Loop()进入消息循环
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//1. 实例化自定义的Handler类对象->>分析1
//注：
// a. 此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueue；
// b. 定义时需传入持有的Activity实例（弱引用）
showhandler = new FHandler(this);
// 2. 启动子线程1
new Thread() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 1;// 消息标识
msg.obj = "AA";// 消息存放
// b. 传入主线程的Handler & 向其MessageQueue发送消息
showhandler.sendMessage(msg);
}
}.start();
// 3. 启动子线程2
new Thread() {
@Override
public void run() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 2;// 消息标识
msg.obj = "BB";// 消息存放
// b. 传入主线程的Handler & 向其MessageQueue发送消息
showhandler.sendMessage(msg);
}
}.start();
}
// 分析1：自定义Handler子类
// 设置为：静态内部类
private static class FHandler extends Handler{
// 定义 弱引用实例
private WeakReference<Activity> reference;
// 在构造方法中传入需持有的Activity实例
public FHandler(Activity activity) {
// 使用WeakReference弱引用持有Activity实例
reference = new WeakReference<Activity>(activity); }
// 通过复写handlerMessage() 从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
Log.d(TAG, "收到线程1的消息");
break;
case 2:
Log.d(TAG, " 收到线程2的消息");
break;
}
}
}
}
解决方案2：当外部类结束生命周期时，清空Handler内消息队列
-
原理
不仅使得 “未被处理 / 正处理的消息 -> Handler实例 -> 外部类” 的引用关系 不复存在，同时 使得 Handler的生命周期（即 消息存在的时期） 与 外部类的生命周期 同步 -
具体方案
当 外部类（此处以Activity为例） 结束生命周期时（此时系统会调用onDestroy（）），清除 Handler消息队列里的所有消息（调用removeCallbacksAndMessages(null)） -
具体代码
@Override
protected void onDestroy() {
super.onDestroy();
mHandler.removeCallbacksAndMessages(null);
// 外部类Activity生命周期结束时，同时清空消息队列 & 结束Handler生命周期
}
- 使用建议
为了保证Handler中消息队列中的所有消息都能被执行，此处推荐使用解决方案1解决内存泄露问题，即 静态内部类 + 弱引用的方式
三、复合使用
Android多线程实现的复合使用包括：
- AsyncTask
- HandlerThread
- IntentService
称为”复用“的主要原因是：这3种方式的本质原理都是Android多线程基础实现（继承Thread类、实现Runnable接口、Handler）的组合实现。下面，我将详细讲解。
1 AsyncTask
1.1 简介
1.2 定义
- 一个Android 已封装好的轻量级异步类
- 属于抽象类，即使用时需 实现子类
public abstract class AsyncTask<Params, Progress, Result> {
...
}
1.3 作用
- 实现多线程 在工作线程中执行任务，如 耗时任务
- 异步通信、消息传递 实现工作线程 & 主线程（UI线程）之间的通信，即：将工作线程的执行结果传递给主线程，从而在主线程中执行相关的UI操作，从而保证线程安全
1.4 优点
- 方便实现异步通信 ：不需使用 “任务线程（如继承Thread类） + Handler”的复杂组合
- 节省资源： 采用线程池的缓存线程 + 复用线程，避免了频繁创建 & 销毁线程所带来的系统资源开销
1.4 类 & 方法介绍
(1) 类定义
AsyncTask类属于抽象类，即使用时需 实现子类
public abstract class AsyncTask<Params, Progress, Result> {
...
}
// 类中参数为3种泛型类型
// 整体作用：控制AsyncTask子类执行线程任务时各个阶段的返回类型
// 具体说明：
// a. Params：开始异步任务执行时传入的参数类型，对应excute（）中传递的参数
// b. Progress：异步任务执行过程中，返回下载进度值的类型
// c. Result：异步任务执行完成后，返回的结果类型，与doInBackground()的返回值类型保持一致
// 注：
// a. 使用时并不是所有类型都被使用
// b. 若无被使用，可用java.lang.Void类型代替
// c. 若有不同业务，需额外再写1个AsyncTask的子类
}
(2) 核心方法
-
AsyncTask 核心 & 常用的方法如下：
-
方法执行顺序如下
1.5 使用步骤
AsyncTask的使用步骤有3个：
- 创建 AsyncTask 子类 & 根据需求实现核心方法
- 创建 AsyncTask子类的实例对象（即 任务实例）
- 手动调用execute(（）从而执行异步线程任务
- 具体介绍如下
/**
* 步骤1：创建AsyncTask子类
* 注：
* a. 继承AsyncTask类
* b. 为3个泛型参数指定类型；若不使用，可用java.lang.Void类型代替
* c. 根据需求，在AsyncTask子类内实现核心方法
*/
private class MyTask extends AsyncTask<Params, Progress, Result> {
....
// 方法1：onPreExecute（）
// 作用：执行 线程任务前的操作
// 注：根据需求复写
@Override
protected void onPreExecute() {
...
}
// 方法2：doInBackground（）
// 作用：接收输入参数、执行任务中的耗时操作、返回 线程任务执行的结果
// 注：必须复写，从而自定义线程任务
@Override
protected String doInBackground(String... params) {
...// 自定义的线程任务
// 可调用publishProgress（）显示进度, 之后将执行onProgressUpdate（）
publishProgress(count);
}
// 方法3：onProgressUpdate（）
// 作用：在主线程 显示线程任务执行的进度
// 注：根据需求复写
@Override
protected void onProgressUpdate(Integer... progresses) {
...
}
// 方法4：onPostExecute（）
// 作用：接收线程任务执行结果、将执行结果显示到UI组件
// 注：必须复写，从而自定义UI操作
@Override
protected void onPostExecute(String result) {
...// UI操作
}
// 方法5：onCancelled()
// 作用：将异步任务设置为：取消状态
@Override
protected void onCancelled() {
...
}
}
/**
* 步骤2：创建AsyncTask子类的实例对象（即 任务实例）
* 注：AsyncTask子类的实例必须在UI线程中创建
*/
MyTask mTask = new MyTask();
/**
* 步骤3：手动调用execute(Params... params) 从而执行异步线程任务
* 注：
* a. 必须在UI线程中调用
* b. 同一个AsyncTask实例对象只能执行1次，若执行第2次将会抛出异常
* c. 执行任务中，系统会自动调用AsyncTask的一系列方法：onPreExecute() 、doInBackground()、onProgressUpdate() 、onPostExecute()
* d. 不能手动调用上述方法
*/
mTask.execute()；
1.6 实例讲解
下面，我将用1个实例讲解 具体如何使用 AsyncTask
(1) 实例说明
点击按钮 则 开启线程执行线程任务
显示后台加载进度
加载完毕后更新UI组件
期间若点击取消按钮，则取消加载
(2) 具体实现
- 主布局文件：activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
tools:context="com.example.carson_ho.handler_learning.MainActivity">
<Button
android:layout_centerInParent="true"
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="点我加载"/>
<TextView
android:id="@+id/text"
android:layout_below="@+id/button"
android:layout_centerInParent="true"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="还没开始加载!" />
<ProgressBar
android:layout_below="@+id/text"
android:id="@+id/progress_bar"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:progress="0"
android:max="100"
style="?android:attr/progressBarStyleHorizontal"/>
<Button
android:layout_below="@+id/progress_bar"
android:layout_centerInParent="true"
android:id="@+id/cancel"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="cancel"/>
</RelativeLayout>
- 主逻辑代码文件：MainActivity.java
public class MainActivity extends AppCompatActivity {
// 线程变量
MyTask mTask;
// 主布局中的UI组件
Button button,cancel; // 加载、取消按钮
TextView text; // 更新的UI组件
ProgressBar progressBar; // 进度条
/**
* 步骤1：创建AsyncTask子类
* 注：
* a. 继承AsyncTask类
* b. 为3个泛型参数指定类型；若不使用，可用java.lang.Void类型代替
* 此处指定为：输入参数 = String类型、执行进度 = Integer类型、执行结果 = String类型
* c. 根据需求，在AsyncTask子类内实现核心方法
*/
private class MyTask extends AsyncTask<String, Integer, String> {
// 方法1：onPreExecute（）
// 作用：执行 线程任务前的操作
@Override
protected void onPreExecute() {
text.setText("加载中");
// 执行前显示提示
}
// 方法2：doInBackground（）
// 作用：接收输入参数、执行任务中的耗时操作、返回 线程任务执行的结果
// 此处通过计算从而模拟“加载进度”的情况
@Override
protected String doInBackground(String... params) {
try {
int count = 0;
int length = 1;
while (count<99) {
count += length;
// 可调用publishProgress（）显示进度, 之后将执行onProgressUpdate（）
publishProgress(count);
// 模拟耗时任务
Thread.sleep(50);
}
}catch (InterruptedException e) {
e.printStackTrace();
}
return null;
}
// 方法3：onProgressUpdate（）
// 作用：在主线程 显示线程任务执行的进度
@Override
protected void onProgressUpdate(Integer... progresses) {
progressBar.setProgress(progresses[0]);
text.setText("loading..." + progresses[0] + "%");
}
// 方法4：onPostExecute（）
// 作用：接收线程任务执行结果、将执行结果显示到UI组件
@Override
protected void onPostExecute(String result) {
// 执行完毕后，则更新UI
text.setText("加载完毕");
}
// 方法5：onCancelled()
// 作用：将异步任务设置为：取消状态
@Override
protected void onCancelled() {
text.setText("已取消");
progressBar.setProgress(0);
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// 绑定UI组件
setContentView(R.layout.activity_main);
button = (Button) findViewById(R.id.button);
cancel = (Button) findViewById(R.id.cancel);
text = (TextView) findViewById(R.id.text);
progressBar = (ProgressBar) findViewById(R.id.progress_bar);
/**
* 步骤2：创建AsyncTask子类的实例对象（即 任务实例）
* 注：AsyncTask子类的实例必须在UI线程中创建
*/
mTask = new MyTask();
// 加载按钮按按下时，则启动AsyncTask
// 任务完成后更新TextView的文本
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
/**
* 步骤3：手动调用execute(Params... params) 从而执行异步线程任务
* 注：
* a. 必须在UI线程中调用
* b. 同一个AsyncTask实例对象只能执行1次，若执行第2次将会抛出异常
* c. 执行任务中，系统会自动调用AsyncTask的一系列方法：onPreExecute() 、doInBackground()、onProgressUpdate() 、onPostExecute()
* d. 不能手动调用上述方法
*/
mTask.execute();
}
});
cancel = (Button) findViewById(R.id.cancel);
cancel.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// 取消一个正在执行的任务,onCancelled方法将会被调用
mTask.cancel(true);
}
});
}
}
1.7 使用时的注意点
在使用AsyncTask时有一些问题需要注意的：
（1） 关于 生命周期
- 结论： AsyncTask不与任何组件绑定生命周期
- 使用建议： 在Activity 或 Fragment中使用 AsyncTask时，最好在Activity 或 Fragment的onDestory（）调用 cancel(boolean)；
（2） 关于 内存泄漏
- 结论 ：若AsyncTask被声明为Activity的非静态内部类，当Activity需销毁时，会因AsyncTask保留对Activity的引用 而导致Activity无法被回收，最终引起内存泄露
- 使用建议： AsyncTask应被声明为Activity的静态内部类
（3） 线程任务执行结果 丢失
- 结论： 当Activity重新创建时（屏幕旋转 / Activity被意外销毁时后恢复），之前运行的AsyncTask（非静态的内部类）持有的之前Activity引用已无效，故复写的onPostExecute()将不生效，即无法更新UI操作
- 使用建议： 在Activity恢复时的对应方法 重启 任务线程
1.8 工作原理
（1） 储备知识：线程
- 简介
- 与进程的区别
（2） 具体原理介绍
- AsyncTask的实现原理 = 线程池 + Handler
其中：线程池用于线程调度、复用 & 执行任务；Handler 用于异步通信
其内部封装了2个线程池 + 1个Handler，具体介绍如下：
（3） 类 & 方法介绍
在进行源码分析前，先介绍AsyncTask中的类 & 核心方法
- 类定义
AsyncTask类属于抽象类，即使用时需 实现子类
public abstract class AsyncTask<Params, Progress, Result> {
...
}
// 类中参数为3种泛型类型
// 整体作用：控制AsyncTask子类执行线程任务时各个阶段的返回类型
// 具体说明：
// a. Params：开始异步任务执行时传入的参数类型，对应excute（）中传递的参数
// b. Progress：异步任务执行过程中，返回下载进度值的类型
// c. Result：异步任务执行完成后，返回的结果类型，与doInBackground()的返回值类型保持一致
// 注：
// a. 使用时并不是所有类型都被使用
// b. 若无被使用，可用java.lang.Void类型代替
// c. 若有不同业务，需额外再写1个AsyncTask的子类
}
- 核心方法
AsyncTask 核心 & 常用的方法如下：
方法执行顺序如下：
1.9 源码分析
本次源码分析将根据 AsyncTask的使用步骤讲解
AsyncTask的使用步骤有4个：
- 创建 AsyncTask 子类 & 根据需求实现核心方法
- 创建 AsyncTask子类的实例对象（即 任务实例）
- 手动调用execute(（）从而执行异步线程任务
- 具体介绍如下
/**
* 步骤1：创建AsyncTask子类
* 注：
* a. 继承AsyncTask类
* b. 为3个泛型参数指定类型；若不使用，可用java.lang.Void类型代替
* c. 根据需求，在AsyncTask子类内实现核心方法
*/
private class MyTask extends AsyncTask<Params, Progress, Result> {
....
// 方法1：onPreExecute（）
// 作用：执行 线程任务前的操作
// 注：根据需求复写
@Override
protected void onPreExecute() {
...
}
// 方法2：doInBackground（）
// 作用：接收输入参数、执行任务中的耗时操作、返回 线程任务执行的结果
// 注：必须复写，从而自定义线程任务
@Override
protected String doInBackground(String... params) {
...// 自定义的线程任务
// 可调用publishProgress（）显示进度, 之后将执行onProgressUpdate（）
publishProgress(count);
}
// 方法3：onProgressUpdate（）
// 作用：在主线程 显示线程任务执行的进度
// 注：根据需求复写
@Override
protected void onProgressUpdate(Integer... progresses) {
...
}
// 方法4：onPostExecute（）
// 作用：接收线程任务执行结果、将执行结果显示到UI组件
// 注：必须复写，从而自定义UI操作
@Override
protected void onPostExecute(String result) {
...// UI操作
}
// 方法5：onCancelled()
// 作用：将异步任务设置为：取消状态
@Override
protected void onCancelled() {
...
}
}
/**
* 步骤2：创建AsyncTask子类的实例对象（即 任务实例）
* 注：AsyncTask子类的实例必须在UI线程中创建
*/
MyTask mTask = new MyTask();
/**
* 步骤3：手动调用execute(Params... params) 从而执行异步线程任务
* 注：
* a. 必须在UI线程中调用
* b. 同一个AsyncTask实例对象只能执行1次，若执行第2次将会抛出异常
* c. 执行任务中，系统会自动调用AsyncTask的一系列方法：onPreExecute() 、doInBackground()、onProgressUpdate() 、onPostExecute()
* d. 不能手动调用上述方法
*/
mTask.execute()；
- 下面，我将根据上述使用步骤进行源码分析:
步骤1：创建AsyncTask子类
在该步骤中，只需知道 “该类中复写的方法将在后续源码中调用” 即可
步骤2：创建AsyncTask子类的实例对象（即 任务实例）
/**
* 具体使用
*/
MyTask mTask = new MyTask();
/**
* 源码分析：AsyncTask的构造函数
*/
public AsyncTask() {
// 1. 初始化WorkerRunnable变量 = 一个可存储参数的Callable对象 ->>分析1
mWorker = new WorkerRunnable<Params, Result>() {
// 在任务执行线程池中回调：THREAD_POOL_EXECUTOR.execute（）
// 下面会详细讲解
public Result call() throws Exception {
// 添加线程的调用标识
mTaskInvoked.set(true);
Result result = null;
try {
// 设置线程的优先级
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
// 执行异步操作 = 耗时操作
// 即 我们使用过程中复写的耗时任务
result = doInBackground(mParams);
Binder.flushPendingCommands();
} catch (Throwable tr) {
mCancelled.set(true);// 若运行异常,设置取消的标志
throw tr;
} finally {
// 把异步操作执行的结果发送到主线程
// 从而更新UI，下面会详细讲解
postResult(result);
}
return result;
}
};
// 2. 初始化FutureTask变量 = 1个FutureTask ->>分析2
mFuture = new FutureTask<Result>(mWorker) {
// done（）简介：FutureTask内的Callable执行完后的调用方法
// 作用：复查任务的调用、将未被调用的任务的结果通过InternalHandler传递到UI线程
@Override
protected void done() {
try {
// 在执行完任务后检查,将没被调用的Result也一并发出 ->>分析3
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) {
//若 发生异常,则将发出null
postResultIfNotInvoked(null);
}
}
};
}
/**
* 分析1：WorkerRunnable类的构造函数
*/
private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {
// 此处的Callable也是任务；
// 与Runnable的区别：Callable存在返回值 = 其泛型
Params[] mParams;
}
/**
* 分析2：FutureTask类的构造函数
* 定义：1个包装任务的包装类
* 注：内部包含Callable 、增加了一些状态标识 & 操作Callable的接口
*/
public FutureTask(Callable<V> callable) {
if (callable == null)
throw new NullPointerException();
this.callable = callable;
this.state = NEW;
}
// 回到调用原处
/**
* 分析3：postResultIfNotInvoked()
*/
private void postResultIfNotInvoked()(Result result) {
// 取得任务标记
final boolean wasTaskInvoked = mTaskInvoked.get();
// 若任务无被执行,将未被调用的任务的结果通过InternalHandler传递到UI线程
if (!wasTaskInvoked) {
postResult(result);
}
}
总结：
- 创建了1个WorkerRunnable类 的实例对象 & 复写了call()方法
- 创建了1个FutureTask类 的实例对象 & 复写了 done()
步骤3：手动调用execute(Params… params)
/**
* 具体使用
*/
mTask.execute()；
/**
* 源码分析：AsyncTask的execute()
*/
public final AsyncTask<Params, Progress, Result> execute(Params... params) {
return executeOnExecutor(sDefaultExecutor, params);
// ->>分析1
}
/**
* 分析1：executeOnExecutor(sDefaultExecutor, params)
* 参数说明：sDefaultExecutor = 任务队列 线程池类（SerialExecutor）的对象
*/
public final AsyncTask<Params, Progress, Result> executeOnExecutor(Executor exec,Params... params) {
// 1. 判断 AsyncTask 当前的执行状态
// PENDING = 初始化状态
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)");
}
}
// 2. 将AsyncTask状态设置为RUNNING状态
mStatus = Status.RUNNING;
// 3. 主线程初始化工作
onPreExecute();
// 4. 添加参数到任务中
mWorker.mParams = params;
// 5. 执行任务
// 此处的exec = sDefaultExecutor = 任务队列 线程池类（SerialExecutor）的对象
// ->>分析2
exec.execute(mFuture);
return this;
}
/**
* 分析2：exec.execute(mFuture)
* 说明：属于任务队列 线程池类（SerialExecutor）的方法
*/
private static class SerialExecutor implements Executor {
// SerialExecutor = 静态内部类
// 即 是所有实例化的AsyncTask对象公有的
// SerialExecutor 内部维持了1个双向队列；
// 容量根据元素数量调节
final ArrayDeque<Runnable> mTasks = new ArrayDeque<Runnable>();
Runnable mActive;
// execute（）被同步锁synchronized修饰
// 即说明：通过锁使得该队列保证AsyncTask中的任务是串行执行的
// 即 多个任务需1个个加到该队列中；然后 执行完队列头部的再执行下一个，以此类推
public synchronized void execute(final Runnable r) {
// 将实例化后的FutureTask类 的实例对象传入
// 即相当于：向队列中加入一个新的任务
mTasks.offer(new Runnable() {
public void run() {
try {
r.run();
} finally {
scheduleNext();->>分析3
}
}
});
// 若当前无任务执行，则去队列中取出1个执行
if (mActive == null) {
scheduleNext();
}
}
// 分析3
protected synchronized void scheduleNext() {
// 1. 取出队列头部任务
if ((mActive = mTasks.poll()) != null) {
// 2. 执行取出的队列头部任务
// 即 调用执行任务线程池类（THREAD_POOL_EXECUTOR）->>继续往下看
THREAD_POOL_EXECUTOR.execute(mActive);
}
}
}
总结：
- 执行任务前，通过 任务队列 线程池类（SerialExecutor）将任务按顺序放入到队列中；
- 通过同步锁 修饰execute（）从而保证AsyncTask中的任务是串行执行的
- 之后的线程任务执行是 通过任务线程池类（THREAD_POOL_EXECUTOR） 进行的。
继续往下分析：THREAD_POOL_EXECUTOR.execute（）
/**
* 源码分析：THREAD_POOL_EXECUTOR.execute（）
* 说明：
* a. THREAD_POOL_EXECUTOR实际上是1个已配置好的可执行并行任务的线程池
* b. 调用THREAD_POOL_EXECUTOR.execute（）实际上是调用线程池的execute()去执行具体耗时任务
* c. 而该耗时任务则是步骤2中初始化WorkerRunnable实例对象时复写的call（）
* 注：下面先看任务执行线程池的线程配置过程，看完后请回到步骤2中的源码分析call（）
*/
// 步骤1：参数设置
//获得当前CPU的核心数
private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
//设置线程池的核心线程数2-4之间,但是取决于CPU核数
private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));
//设置线程池的最大线程数为 CPU核数*2+1
private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;
//设置线程池空闲线程存活时间30s
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());
}
};
//初始化存储任务的队列为LinkedBlockingQueue 最大容量为128
private static final BlockingQueue<Runnable> sPoolWorkQueue =
new LinkedBlockingQueue<Runnable>(128);
// 步骤2： 根据参数配置执行任务线程池，即 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);
// 设置核心线程池的 超时时间也为30s
threadPoolExecutor.allowCoreThreadTimeOut(true);
THREAD_POOL_EXECUTOR = threadPoolExecutor;
}
// 请回到步骤2中的源码分析call（）
至此，我们回到步骤2中的源码分析call（）
/**
* 步骤2的源码分析：AsyncTask的构造函数
*/
public AsyncTask() {
// 1. 初始化WorkerRunnable变量 = 一个可存储参数的Callable对象
mWorker = new WorkerRunnable<Params, Result>() {
public Result call() throws Exception {
// 添加线程的调用标识
mTaskInvoked.set(true);
Result result = null;
try {
// 设置线程的优先级
Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND);
// 执行异步操作 = 耗时操作
// 即 我们使用过程中复写的耗时任务
result = doInBackground(mParams);
Binder.flushPendingCommands();
} catch (Throwable tr) {
mCancelled.set(true);// 若运行异常,设置取消的标志
throw tr;
} finally {
// 把异步操作执行的结果发送到主线程
// 从而更新UI ->>分析1
postResult(result);
}
return result;
}
};
.....// 省略
}
/**
* 分析1：postResult(result)
*/
private Result postResult(Result result) {
@SuppressWarnings("unchecked")
// 创建Handler对象 ->> 源自InternalHandler类—>>分析2
Message message = getHandler().obtainMessage(MESSAGE_POST_RESULT,
new AsyncTaskResult<Result>(this, result));
// 发送消息到Handler中
message.sendToTarget();
return result;
}
/**
* 分析2：InternalHandler类
*/
private static class InternalHandler extends Handler {
// 构造函数
public InternalHandler() {
super(Looper.getMainLooper());
// 获取的是主线程的Looper()
// 故 AsyncTask的实例创建 & execute（）必须在主线程使用
}
@Override
public void handleMessage(Message msg) {
AsyncTaskResult<?> result = (AsyncTaskResult<?>) msg.obj;
switch (msg.what) {
// 若收到的消息 = MESSAGE_POST_RESULT
// 则通过finish() 将结果通过Handler传递到主线程
case MESSAGE_POST_RESULT:
result.mTask.finish(result.mData[0]); ->>分析3
break;
// 若收到的消息 = MESSAGE_POST_PROGRESS
// 则回调onProgressUpdate()通知主线程更新进度的操作
case MESSAGE_POST_PROGRESS:
result.mTask.onProgressUpdate(result.mData);
break;
}
}
}
/**
* 分析3：result.mTask.finish(result.mData[0])
*/
private void finish(Result result) {
// 先判断是否调用了Cancelled()
// 1. 若调用了则执行我们复写的onCancelled（）
// 即 取消任务时的操作
if (isCancelled()) {
onCancelled(result);
} else {
// 2. 若无调用Cancelled()，则执行我们复写的onPostExecute(result)
// 即更新UI操作
onPostExecute(result);
}
// 注：不管AsyncTask是否被取消，都会将AsyncTask的状态变更为：FINISHED
mStatus = Status.FINISHED;
}
总结
- 任务线程池类（THREAD_POOL_EXECUTOR）实际上是1个已配置好的可执行并行任务的线程池
- 调用THREAD_POOL_EXECUTOR.execute（）实际上是调用线程池的execute()去执行具体耗时任务
- 而该耗时任务则是步骤2中初始化 WorkerRunnable实例对象时复写的call（）内容
- 在call（）方法里，先调用 我们复写的doInBackground(mParams)执行耗时操作
- 再调用postResult(result)， 通过 InternalHandler 类 将任务消息传递到主线程；根据消息标识（MESSAGE_POST_RESULT）判断，最终通过finish(）调用我们复写的onPostExecute(result)，从而实现UI更新操作
至此，关于AsyncTask的源码 分析完毕，附上一份最终总结：
总结
本文介绍了多线程中的AsyncTask的 工作原理 & 源码分析，总结如下：
2 HandlerThread
2.1 简介
2.2 使用步骤
- HandlerThread的本质：继承Thread类 & 封装Handler类
- HandlerThread的使用步骤分为5步
// 步骤1：创建HandlerThread实例对象
// 传入参数 = 线程名字，作用 = 标记该线程
HandlerThread mHandlerThread = new HandlerThread("handlerThread");
// 步骤2：启动线程
mHandlerThread.start();
// 步骤3：创建工作线程Handler & 复写handleMessage（）
// 作用：关联HandlerThread的Looper对象、实现消息处理操作 & 与其他线程进行通信
// 注：消息处理操作（HandlerMessage（））的执行线程 = mHandlerThread所创建的工作线程中执行
Handler workHandler = new Handler( handlerThread.getLooper() ) {
@Override
public boolean handleMessage(Message msg) {
...//消息处理
return true;
}
});
// 步骤4：使用工作线程Handler向工作线程的消息队列发送消息
// 在工作线程中，当消息循环时取出对应消息 & 在工作线程执行相关操作
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 2; //消息的标识
msg.obj = "B"; // 消息的存放
// b. 通过Handler发送消息到其绑定的消息队列
workHandler.sendMessage(msg);
// 步骤5：结束线程，即停止线程的消息循环
mHandlerThread.quit();
2.3 实例讲解
下面，我将用一个实例讲解HandlerThread该如何使用
2.3.1 实例说明
- 点击按钮实现延迟操作
- 最终更新UI组件
2.3.2 具体实现
- 主布局文件：activity_main.xml
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:gravity="center"
tools:context="com.example.carson_ho.handler_learning.MainActivity">
<TextView
android:id="@+id/text1"
android:layout_centerInParent="true"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="测试结果" />
<Button
android:id="@+id/button1"
android:layout_centerInParent="true"
android:layout_below="@+id/text1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="点击延迟1s + 显示我爱学习"/>
<Button
android:id="@+id/button2"
android:layout_centerInParent="true"
android:layout_below="@+id/button1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="点击延迟3s + 显示我不爱学习"/>
<Button
android:id="@+id/button3"
android:layout_centerInParent="true"
android:layout_below="@+id/button2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="结束线程的消息循环"/>
</RelativeLayout>
- 主代码文件：MainActivity.java
public class MainActivity extends AppCompatActivity {
Handler mainHandler,workHandler;
HandlerThread mHandlerThread;
TextView text;
Button button1,button2,button3;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// 显示文本
text = (TextView) findViewById(R.id.text1);
// 创建与主线程关联的Handler
mainHandler = new Handler();
/**
* 步骤1：创建HandlerThread实例对象
* 传入参数 = 线程名字，作用 = 标记该线程
*/
mHandlerThread = new HandlerThread("handlerThread");
/**
* 步骤2：启动线程
*/
mHandlerThread.start();
/**
* 步骤3：创建工作线程Handler & 复写handleMessage（）
* 作用：关联HandlerThread的Looper对象、实现消息处理操作 & 与其他线程进行通信
* 注：消息处理操作（HandlerMessage（））的执行线程 = mHandlerThread所创建的工作线程中执行
*/
workHandler = new Handler(mHandlerThread.getLooper()){
@Override
// 消息处理的操作
public void handleMessage(Message msg)
{
//设置了两种消息处理操作,通过msg来进行识别
switch(msg.what){
// 消息1
case 1:
try {
//延时操作
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// 通过主线程Handler.post方法进行在主线程的UI更新操作
mainHandler.post(new Runnable() {
@Override
public void run () {
text.setText("我爱学习");
}
});
break;
// 消息2
case 2:
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
mainHandler.post(new Runnable() {
@Override
public void run () {
text.setText("我不喜欢学习");
}
});
break;
default:
break;
}
}
};
/**
* 步骤4：使用工作线程Handler向工作线程的消息队列发送消息
* 在工作线程中，当消息循环时取出对应消息 & 在工作线程执行相关操作
*/
// 点击Button1
button1 = (Button) findViewById(R.id.button1);
button1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// 通过sendMessage（）发送
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 1; //消息的标识
msg.obj = "A"; // 消息的存放
// b. 通过Handler发送消息到其绑定的消息队列
workHandler.sendMessage(msg);
}
});
// 点击Button2
button2 = (Button) findViewById(R.id.button2);
button2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
// 通过sendMessage（）发送
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 2; //消息的标识
msg.obj = "B"; // 消息的存放
// b. 通过Handler发送消息到其绑定的消息队列
workHandler.sendMessage(msg);
}
});
// 点击Button3
// 作用：退出消息循环
button3 = (Button) findViewById(R.id.button3);
button3.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
mHandlerThread.quit();
}
});
}
}
2.4 特别注意点
在HandlerThread中，有2个问题需注意的：内存泄漏 & 连续发送消息
2.4.1 内存泄露
- 在上面的例子中，出现了严重的警告：
In Android, Handler classes should be static or leaks might occur.
即造成了严重的内存泄漏
2.4.2 连续发送消息
- 当你连续点击3下时，发现并无按照最新点击的按钮操作显示，而是按顺序的一个个显示出来
- 原因：使用HandlerThread时只是开了一个工作线程，当你点击了n下后，只是将n个消息发送到消息队列MessageQueue里排队，等候派发消息给Handler再进行对应的操作
2.5 工作原理
内部原理 = Thread类 + Handler类机制，即：
- 通过继承Thread类，快速地创建1个带有Looper对象的新工作线程
- 通过封装Handler类，快速创建Handler & 与其他线程进行通信
2.6 源码分析
本次源码分析将根据 HandlerThread的使用步骤讲解
HandlerThread的使用步骤有5个：
// 步骤1：创建HandlerThread实例对象
// 传入参数 = 线程名字，作用 = 标记该线程
HandlerThread mHandlerThread = new HandlerThread("handlerThread");
// 步骤2：启动线程
mHandlerThread.start();
// 步骤3：创建工作线程Handler & 复写handleMessage（）
// 作用：关联HandlerThread的Looper对象、实现消息处理操作 & 与其他线程进行通信
// 注：消息处理操作（HandlerMessage（））的执行线程 = mHandlerThread所创建的工作线程中执行
Handler workHandler = new Handler( handlerThread.getLooper() ) {
@Override
public boolean handleMessage(Message msg) {
...//消息处理
return true;
}
});
// 步骤4：使用工作线程Handler向工作线程的消息队列发送消息
// 在工作线程中，当消息循环时取出对应消息 & 在工作线程执行相关操作
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 2; //消息的标识
msg.obj = "B"; // 消息的存放
// b. 通过Handler发送消息到其绑定的消息队列
workHandler.sendMessage(msg);
// 步骤5：结束线程，即停止线程的消息循环
mHandlerThread.quit();
下面，我将根据上述使用步骤进行源码分析
步骤1：创建HandlerThread的实例对象
/**
* 具体使用
* 传入参数 = 线程名字，作用 = 标记该线程
*/
HandlerThread mHandlerThread = new HandlerThread("handlerThread");
/**
* 源码分析：HandlerThread类的构造方法
*/
public class HandlerThread extends Thread {
// 继承自Thread类
int mPriority; // 线程优先级
int mTid = -1; // 当前线程id
Looper mLooper; // 当前线程持有的Looper对象
// HandlerThread类有2个构造方法
// 区别在于：设置当前线程的优先级参数，即可自定义设置 or 使用默认优先级
// 方式1. 默认优先级
public HandlerThread(String name) {
// 通过调用父类默认的方法创建线程
super(name);
mPriority = Process.THREAD_PRIORITY_DEFAULT;
}
// 方法2. 自定义设置优先级
public HandlerThread(String name, int priority) {
super(name);
mPriority = priority;
}
...
}
总结
- HandlerThread类继承自Thread类
- 创建HandlerThread类对象 = 创建Thread类对象 + 设置线程优先级 = 新开1个工作线程 + 设置线程优先级
步骤2：启动线程
/**
* 具体使用
*/
mHandlerThread.start();
/**
* 源码分析：此处调用的是父类（Thread类）的start()，最终回调HandlerThread的run（）
*/
@Override
public void run() {
// 1. 获得当前线程的id
mTid = Process.myTid();
// 2. 创建1个Looper对象 & MessageQueue对象
Looper.prepare();
// 3. 通过持有锁机制来获得当前线程的Looper对象
synchronized (this) {
mLooper = Looper.myLooper();
// 发出通知：当前线程已经创建mLooper对象成功
// 此处主要是通知getLooper（）中的wait（）
notifyAll();
// 此处使用持有锁机制 + notifyAll() 是为了保证后面获得Looper对象前就已创建好Looper对象
}
// 4. 设置当前线程的优先级
Process.setThreadPriority(mPriority);
// 5. 在线程循环前做一些准备工作 ->>分析1
// 该方法实现体是空的，子类可实现 / 不实现该方法
onLooperPrepared();
// 6. 进行消息循环，即不断从MessageQueue中取消息 & 派发消息
Looper.loop();
mTid = -1;
}
}
/**
* 分析1：onLooperPrepared();
* 说明：该方法实现体是空的，子类可实现 / 不实现该方法
*/
protected void onLooperPrepared() {
}
总结
- 为当前工作线程（即步骤1创建的线程）创建1个Looper对象 & MessageQueue对象
- 通过持有锁机制来获得当前线程的Looper对象
- 发出通知：当前线程已经创建mLooper对象成功
- 工作线程进行消息循环，即不断从MessageQueue中取消息 & 派发消息
步骤3：创建工作线程Handler & 复写handleMessage（）
/**
* 具体使用
* 作用：将Handler关联HandlerThread的Looper对象、实现消息处理操作 & 与其他线程进行通信
* 注：消息处理操作（HandlerMessage（））的执行线程 = mHandlerThread所创建的工作线程中执行
*/
Handler workHandler = new Handler( handlerThread.getLooper() ) {
@Override
public boolean handleMessage(Message msg) {
...//消息处理
return true;
}
});
/**
* 源码分析：handlerThread.getLooper()
* 作用：获得当前HandlerThread线程中的Looper对象
*/
public Looper getLooper() {
// 若线程不是存活的，则直接返回null
if (!isAlive()) {
return null;
}
// 若当前线程存活，再判断线程的成员变量mLooper是否为null
// 直到线程创建完Looper对象后才能获得Looper对象，若Looper对象未创建成功，则阻塞
synchronized (this) {
while (isAlive() && mLooper == null) {
try {
// 此处会调用wait方法去等待
wait();
} catch (InterruptedException e) {
}
}
}
// 上述步骤run（）使用 持有锁机制 + notifyAll() 获得Looper对象后
// 则通知当前线程的wait（）结束等待 & 跳出循环
// 最终getLooper()返回的是在run（）中创建的mLooper对象
return mLooper;
}
总结
- 在获得HandlerThread工作线程的Looper对象时存在一个同步的问题：只有当线程创建成功 & 其对应的Looper对象也创建成功后才能获得Looper的值，才能将创建的Handler 与
工作线程的Looper对象绑定，从而将Handler绑定工作线程- 解决方案：即保证同步的解决方案 = 同步锁、wait（） 和 notifyAll（），即 在run()中成功创建Looper对象后，立即调用notifyAll（）通知 getLooper()中的wait（）结束等待 &
返回run()中成功创建的Looper对象，使得Handler与该Looper对象绑定
步骤4：使用工作线程Handler向工作线程的消息队列发送消息
/**
* 具体使用
* 作用：在工作线程中，当消息循环时取出对应消息 & 在工作线程执行相关操作
* 注：消息处理操作（HandlerMessage（））的执行线程 = mHandlerThread所创建的工作线程中执行
*/
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 2; //消息的标识
msg.obj = "B"; // 消息的存放
// b. 通过Handler发送消息到其绑定的消息队列
workHandler.sendMessage(msg);
/**
* 源码分析：workHandler.sendMessage(msg)
* 此处的源码即Handler的源码，故不作过多描述
*/
步骤5：结束线程，即停止线程的消息循环
/**
* 具体使用
*/
mHandlerThread.quit();
/**
* 源码分析：mHandlerThread.quit()
* 说明：
* a. 该方法属于HandlerThread类
* b. HandlerThread有2种让当前线程退出消息循环的方法：quit() 、quitSafely()
*/
// 方式1：quit()
// 特点：效率高，但线程不安全
public boolean quit() {
Looper looper = getLooper();
if (looper != null) {
looper.quit();
return true;
}
return false;
}
// 方式2：quitSafely()
// 特点：效率低，但线程安全
public boolean quitSafely() {
Looper looper = getLooper();
if (looper != null) {
looper.quitSafely();
return true;
}
return false;
}
// 注：上述2个方法最终都会调用MessageQueue.quit（boolean safe）->>分析1
/**
* 分析1：MessageQueue.quit（boolean safe）
*/
void quit(boolean safe) {
if (!mQuitAllowed) {
throw new IllegalStateException("Main thread not allowed to quit.");
}
synchronized (this) {
if (mQuitting) {
return;
}
mQuitting = true;
if (safe) {
removeAllFutureMessagesLocked(); // 方式1（不安全）会调用该方法 ->>分析2
} else {
removeAllMessagesLocked(); // 方式2（安全）会调用该方法 ->>分析3
}
// We can assume mPtr != 0 because mQuitting was previously false.
nativeWake(mPtr);
}
}
/**
* 分析2：removeAllMessagesLocked()
* 原理：遍历Message链表、移除所有信息的回调 & 重置为null
*/
private void removeAllMessagesLocked() {
Message p = mMessages;
while (p != null) {
Message n = p.next;
p.recycleUnchecked();
p = n;
}
mMessages = null;
}
/**
* 分析3：removeAllFutureMessagesLocked()
* 原理：先判断当前消息队列是否正在处理消息
* a. 若不是,则类似分析2移除消息
* b. 若是，则等待该消息处理处理完毕再使用分析2中的方式移除消息退出循环
* 结论：退出方法安全与否（quitSafe（） 或 quit（）），在于该方法移除消息、退出循环时是否在意当前队列是否正在处理消息
*/
private void removeAllFutureMessagesLocked() {
final long now = SystemClock.uptimeMillis();
Message p = mMessages;
if (p != null) {
// 判断当前消息队列是否正在处理消息
// a. 若不是，则直接移除所有回调
if (p.when > now) {
removeAllMessagesLocked();
} else {
// b. 若是正在处理，则等待该消息处理处理完毕再退出该循环
Message n;
for (;;) {
n = p.next;
if (n == null) {
return;
}
if (n.when > now) {
break;
}
p = n;
}
p.next = null;
do {
p = n;
n = p.next;
p.recycleUnchecked();
} while (n != null);
}
}
}
至此，关于HandlerThread源码的分析完毕。
总结
本文全面分析了多线程中HandlerThread的源码，总结如下：
3.IntentService
3.1 定义
Android里的一个封装类，继承四大组件之一的Service
3.2 作用
处理异步请求 & 实现多线程
3.3 使用场景
线程任务 需 按顺序、在后台执行
- 最常见的场景：离线下载
- 不符合多个数据同时请求的场景：所有的任务都在同一个Thread looper里执行
3.4 使用步骤
步骤1：定义 IntentService的子类，需复写onHandleIntent()方法
步骤2：在Manifest.xml中注册服务
步骤3：在Activity中开启Service服务
3.5 实例讲解
步骤1：定义 IntentService的子类
传入线程名称、复写onHandleIntent()方法
public class myIntentService extends IntentService {
/**
* 在构造函数中传入线程名字
**/
public myIntentService() {
// 调用父类的构造函数
// 参数 = 工作线程的名字
super("myIntentService");
}
/**
* 复写onHandleIntent()方法
* 根据 Intent实现 耗时任务 操作
**/
@Override
protected void onHandleIntent(Intent intent) {
// 根据 Intent的不同，进行不同的事务处理
String taskName = intent.getExtras().getString("taskName");
switch (taskName) {
case "task1":
Log.i("myIntentService", "do task1");
break;
case "task2":
Log.i("myIntentService", "do task2");
break;
default:
break;
}
}
@Override
public void onCreate() {
Log.i("myIntentService", "onCreate");
super.onCreate();
}
/**
* 复写onStartCommand()方法
* 默认实现 = 将请求的Intent添加到工作队列里
**/
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.i("myIntentService", "onStartCommand");
return super.onStartCommand(intent, flags, startId);
}
@Override
public void onDestroy() {
Log.i("myIntentService", "onDestroy");
super.onDestroy();
}
}
步骤2：在Manifest.xml中注册服务
<service android:name=".myIntentService">
<intent-filter >
<action android:name="cn.scu.finch"/>
</intent-filter>
</service>
步骤3：在Activity中开启Service服务
public class MainActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
// 同一服务只会开启1个工作线程
// 在onHandleIntent（）函数里，依次处理传入的Intent请求
// 将请求通过Bundle对象传入到Intent，再传入到服务里
// 请求1
Intent i = new Intent("cn.scu.finch");
Bundle bundle = new Bundle();
bundle.putString("taskName", "task1");
i.putExtras(bundle);
startService(i);
// 请求2
Intent i2 = new Intent("cn.scu.finch");
Bundle bundle2 = new Bundle();
bundle2.putString("taskName", "task2");
i2.putExtras(bundle2);
startService(i2);
startService(i); //多次启动
}
}
测试结果
3.6 对比
此处主要讲解IntentService与四大组件Service、普通线程的区别。
3.6.1 与Service的区别
示意图
3.6.2 与其他线程的区别
3.7 工作原理
3.7.1 流程示意图
IntentService的工作原理 & 源码工作流程如下：
3.7.2 特别注意
若启动IntentService 多次，那么 每个耗时操作 则 以队列的方式 在 IntentService的 onHandleIntent回调方法中依次执行，执行完自动结束
接下来，我们将通过 源码分析 解决以下问题：
- IntentService 如何单独开启1个新的工作线程
- IntentService 如何通过onStartCommand() 将Intent 传递给服务 & 依次插入到工作队列中
3.8 源码分析
问题1：IntentService如何单独开启1个新的工作线程
- 主要分析内容 = IntentService源码中的 onCreate()方法
@Override
public void onCreate() {
super.onCreate();
// 1. 通过实例化andlerThread新建线程 & 启动；故 使用IntentService时，不需额外新建线程
// HandlerThread继承自Thread，内部封装了 Looper
HandlerThread thread = new HandlerThread("IntentService[" + mName + "]");
thread.start();
// 2. 获得工作线程的 Looper & 维护自己的工作队列
mServiceLooper = thread.getLooper();
// 3. 新建mServiceHandler & 绑定上述获得Looper
// 新建的Handler 属于工作线程 ->>分析1
mServiceHandler = new ServiceHandler(mServiceLooper);
}
/**
* 分析1：ServiceHandler源码分析
**/
private final class ServiceHandler extends Handler {
// 构造函数
public ServiceHandler(Looper looper) {
super(looper);
}
// IntentService的handleMessage（）把接收的消息交给onHandleIntent()处理
@Override
public void handleMessage(Message msg) {
// onHandleIntent 方法在工作线程中执行
// onHandleIntent() = 抽象方法，使用时需重写 ->>分析2
onHandleIntent((Intent)msg.obj);
// 执行完调用 stopSelf() 结束服务
stopSelf(msg.arg1);
}
}
/**
* 分析2： onHandleIntent()源码分析
* onHandleIntent() = 抽象方法，使用时需重写
**/
@WorkerThread
protected abstract void onHandleIntent(Intent intent);
问题2：IntentService 如何通过onStartCommand() 将Intent 传递给服务 & 依次插入到工作队列中
/**
* onStartCommand（）源码分析
* onHandleIntent() = 抽象方法，使用时需重写
**/
public int onStartCommand(Intent intent, int flags, int startId) {
// 调用onStart（）->>分析1
onStart(intent, startId);
return mRedelivery ? START_REDELIVER_INTENT : START_NOT_STICKY;
}
/**
* 分析1：onStart(intent, startId)
**/
public void onStart(Intent intent, int startId) {
// 1. 获得ServiceHandler消息的引用
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
// 2. 把 Intent参数 包装到 message 的 obj 发送消息中，
//这里的Intent = 启动服务时startService(Intent) 里传入的 Intent
msg.obj = intent;
// 3. 发送消息，即 添加到消息队列里
mServiceHandler.sendMessage(msg);
}
至此，关于IntentService的源码分析讲解完毕。
3.9 源码总结
从上面源码可看出：IntentService本质 = Handler + HandlerThread：
- 通过HandlerThread 单独开启1个工作线程：IntentService
- 创建1个内部 Handler ：ServiceHandler
- 绑定 ServiceHandler 与 IntentService
- 通过 onStartCommand() 传递服务intent 到ServiceHandler 、依次插入Intent到工作队列中 & 逐个发送给 onHandleIntent()
- 通过onHandleIntent() 依次处理所有Intent对象所对应的任务
- 因此我们通过复写onHandleIntent() & 在里面 根据Intent的不同进行不同线程操作 即可
3.10 注意事项
此处，有两个注意事项需要关注的：
- 工作任务队列 = 顺序执行
- 不建议通过 bindService() 启动 IntentService
注意事项1：工作任务队列 = 顺序执行
即 若一个任务正在IntentService中执行，此时你再发送1个新的任务请求，这个新的任务会一直等待直到前面一个任务执行完毕后才开始执行
原因：
- 由于onCreate()只会调用一次 = 只会创建1个工作线程；
- 当多次调用 startService(Intent)时（即 onStartCommand（）也会调用多次），其实不会创建新的工作线程，只是把消息加入消息队列中 & 等待执行。 所以，多次启动 IntentService 会按顺序执行事件
- 若服务停止，则会清除消息队列中的消息，后续的事件不执行
注意事项2：不建议通过 bindService() 启动 IntentService
原因：
// 在IntentService中，onBind()`默认返回null
@Override
public IBinder onBind(Intent intent) {
return null;
}
- 采用 bindService()启动 IntentService的生命周期如下：
onCreate() ->> onBind() ->> onunbind()->> onDestory()
- 即，并不会调用onStart() 或 onStartcommand()，故不会将消息发送到消息队列，那么onHandleIntent()将不会回调，即无法实现多线程的操作,此时，你应该使用Service，而不是IntentService
三、 高级使用
Android多线程的高级使用主要是线程池（ThreadPool）。
1. 简介
示意图
2. 具体使用 & 工作原理
具体参考Android线程池使用及其原理
以上就是多线程实现的方式，参考https://juejin.im/post/5d12c1c66fb9a07ee30e2821