全面详解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（），内容 = 定义线程行为@Overridepublic void run(){... // 定义的线程行为}
}// 步骤3：创建线程对象，即 实例化线程类MyThread mt=new MyThread(“线程名称”);// 步骤4：通过 线程对象 控制线程的状态，如 运行、睡眠、挂起  / 停止// 此处采用 start（）开启线程mt.start();

（3）简便使用：匿名类
很多情况下，开发者会选择一种更加方便的方法去创建线程：匿名类

// 步骤1：采用匿名类，直接 创建 线程类的实例new Thread("线程名称") {// 步骤2：复写run（），内容 = 定义线程行为@Overridepublic 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">//设置一个按钮以启动卖票<Buttonandroid: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/张@Overridepublic 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/张@Overridepublic void run(){while (ticket>0){ticket--;System.out.println(name + "卖掉了1张票，剩余票数为:"+ticket);try {Thread.sleep(3000);//卖票速度是1s一张} catch (InterruptedException e) {e.printStackTrace();}}}}@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);//Button按下时会开启一个新线程执行卖票button = (Button) findViewById(R.id.button);button.setOnClickListener(new View.OnClickListener() {@Overridepublic 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（），定义线程行为@Overridepublic 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">
//设置按钮用以启动线程<Buttonandroid: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/张@Overridepublic void run(){while (ticket>0){ticket--;System.out.println(Thread.currentThread().getName() + "卖掉了1张票，剩余票数为:"+ticket);try {Thread.sleep(1000);//卖票速度是1s一张} catch (InterruptedException e) {e.printStackTrace();}}}}@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);//Button按下时会开启一个新线程执行卖票button = (Button) findViewById(R.id.button);button.setOnClickListener(new View.OnClickListener() {@Overridepublic 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的操作@Overridepublic 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类、实现RunnablemHandler.sendMessage(msg);// 步骤5：开启工作线程（同时启动了Handler）// 多线程可采用AsyncTask、继承Thread类、实现Runnable/** * 方式2：匿名内部类*/// 步骤1：在主线程中 通过匿名内部类 创建Handler类对象private Handler mhandler = new  Handler(){// 通过复写handlerMessage()从而确定更新UI的操作@Overridepublic void handleMessage(Message msg) {...// 需执行的UI操作}};// 步骤2：创建消息对象Message msg = Message.obtain(); // 实例化消息对象msg.what = 1; // 消息标识msg.obj = "AA"; // 消息内容存放// 步骤3：在工作线程中 通过Handler发送消息到消息队列中// 多线程可采用AsyncTask、继承Thread类、实现RunnablemHandler.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() {@Overridepublic 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"><TextViewandroid: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的操作@Overridepublic void handleMessage(Message msg) {// 根据不同线程发送过来的消息，执行不同的UI操作// 根据 Message对象的what属性 标识不同的消息switch (msg.what) {case 1:mTextView.setText("执行了线程1的UI操作");break;case 2:mTextView.setText("执行了线程2的UI操作");break;}}}@Overrideprotected 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() {@Overridepublic 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() {@Overridepublic 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;@Overrideprotected 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的操作@Overridepublic 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() {@Overridepublic 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() {@Overridepublic 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;@Overrideprotected 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() {@Overridepublic void run() {try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}// 通过psot（）发送，需传入1个Runnable对象mHandler.post(new Runnable() {@Overridepublic void run() {// 指定操作UI内容mTextView.setText("执行了线程1的UI操作");}});}}.start();// 步骤3：开启工作线程（同时启动了Handler）// 此处用2个工作线程展示new Thread() {@Overridepublic void run() {try {Thread.sleep(6000);} catch (InterruptedException e) {e.printStackTrace();}mHandler.post(new Runnable() {@Overridepublic 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的操作@Overridepublic void handleMessage(Message msg) {...// 需执行的UI操作}};// 步骤2：创建消息对象Message msg = Message.obtain(); // 实例化消息对象msg.what = 1; // 消息标识msg.obj = "AA"; // 消息内容存放// 步骤3：在工作线程中 通过Handler发送消息到消息队列中// 多线程可采用AsyncTask、继承Thread类、实现RunnablemHandler.sendMessage(msg);// 步骤4：开启工作线程（同时启动了Handler）// 多线程可采用AsyncTask、继承Thread类、实现Runnable

源码分析

下面，我将根据上述每个步骤进行源码分析

步骤1：在主线程中通过匿名内部类创建Handler类对象

/** * 具体使用*/private Handler mhandler = new  Handler(){// 通过复写handlerMessage()从而确定更新UI的操作@Overridepublic 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 派发消息到对应的Handlermsg.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) ->> 分析3handleMessage(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 flagsPoolSize--;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方法 ->>分析3return 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发送的消息，最终是保存到消息队列->>分析4return 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() {@Overridepublic 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() {@Overridepublic 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方法 ->>分析3return 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 派发消息到对应的Handlermsg.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（）->> 分析2if (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()进入消息循环@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);//1. 实例化自定义的Handler类对象->>分析1//注：此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueueshowhandler = new FHandler();// 2. 启动子线程1new Thread() {@Overridepublic 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. 启动子线程2new Thread() {@Overridepublic 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的操作@Overridepublic 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()进入消息循环@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);//1. 通过匿名内部类实例化的Handler类对象//注：此处并无指定Looper，故自动绑定当前线程(主线程)的Looper、MessageQueueshowhandler = new  Handler(){// 通过复写handlerMessage()从而确定更新UI的操作@Overridepublic void handleMessage(Message msg) {switch (msg.what) {case 1:Log.d(TAG, "收到线程1的消息");break;case 2:Log.d(TAG, " 收到线程2的消息");break;}}};// 2. 启动子线程1new Thread() {@Overridepublic 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. 启动子线程2new Thread() {@Overridepublic 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()进入消息循环@Overrideprotected 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. 启动子线程1new Thread() {@Overridepublic 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. 启动子线程2new Thread() {@Overridepublic 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的操作@Overridepublic 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)）
具体代码

@Overrideprotected 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（）// 作用：执行 线程任务前的操作// 注：根据需求复写@Overrideprotected void onPreExecute() {...}// 方法2：doInBackground（）// 作用：接收输入参数、执行任务中的耗时操作、返回 线程任务执行的结果// 注：必须复写，从而自定义线程任务@Overrideprotected String doInBackground(String... params) {...// 自定义的线程任务// 可调用publishProgress（）显示进度, 之后将执行onProgressUpdate（）publishProgress(count);}// 方法3：onProgressUpdate（）// 作用：在主线程 显示线程任务执行的进度// 注：根据需求复写@Overrideprotected void onProgressUpdate(Integer... progresses) {...}// 方法4：onPostExecute（）// 作用：接收线程任务执行结果、将执行结果显示到UI组件// 注：必须复写，从而自定义UI操作@Overrideprotected void onPostExecute(String result) {...// UI操作}// 方法5：onCancelled()// 作用：将异步任务设置为：取消状态@Overrideprotected 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"><Buttonandroid:layout_centerInParent="true"android:id="@+id/button"android:layout_width="wrap_content"android:layout_height="wrap_content"android:text="点我加载"/><TextViewandroid:id="@+id/text"android:layout_below="@+id/button"android:layout_centerInParent="true"android:layout_width="wrap_content"android:layout_height="wrap_content"android:text="还没开始加载!" /><ProgressBarandroid: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"/><Buttonandroid: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（）// 作用：执行 线程任务前的操作@Overrideprotected void onPreExecute() {text.setText("加载中");// 执行前显示提示}// 方法2：doInBackground（）// 作用：接收输入参数、执行任务中的耗时操作、返回 线程任务执行的结果// 此处通过计算从而模拟“加载进度”的情况@Overrideprotected 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（）// 作用：在主线程 显示线程任务执行的进度@Overrideprotected void onProgressUpdate(Integer... progresses) {progressBar.setProgress(progresses[0]);text.setText("loading..." + progresses[0] + "%");}// 方法4：onPostExecute（）// 作用：接收线程任务执行结果、将执行结果显示到UI组件@Overrideprotected void onPostExecute(String result) {// 执行完毕后，则更新UItext.setText("加载完毕");}// 方法5：onCancelled()// 作用：将异步任务设置为：取消状态@Overrideprotected void onCancelled() {text.setText("已取消");progressBar.setProgress(0);}}@Overrideprotected 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() {@Overridepublic 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() {@Overridepublic 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（）// 作用：执行 线程任务前的操作// 注：根据需求复写@Overrideprotected void onPreExecute() {...}// 方法2：doInBackground（）// 作用：接收输入参数、执行任务中的耗时操作、返回 线程任务执行的结果// 注：必须复写，从而自定义线程任务@Overrideprotected String doInBackground(String... params) {...// 自定义的线程任务// 可调用publishProgress（）显示进度, 之后将执行onProgressUpdate（）publishProgress(count);}// 方法3：onProgressUpdate（）// 作用：在主线程 显示线程任务执行的进度// 注：根据需求复写@Overrideprotected void onProgressUpdate(Integer... progresses) {...}// 方法4：onPostExecute（）// 作用：接收线程任务执行结果、将执行结果显示到UI组件// 注：必须复写，从而自定义UI操作@Overrideprotected void onPostExecute(String result) {...// UI操作}// 方法5：onCancelled()// 作用：将异步任务设置为：取消状态@Overrideprotected 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对象 ->>分析1mWorker = 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 ->>分析2mFuture = new FutureTask<Result>(mWorker) {// done（）简介：FutureTask内的Callable执行完后的调用方法// 作用：复查任务的调用、将未被调用的任务的结果通过InternalHandler传递到UI线程@Overrideprotected void done() {try {// 在执行完任务后检查,将没被调用的Result也一并发出 ->>分析3postResultIfNotInvoked(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) {//若 发生异常,则将发出nullpostResultIfNotInvoked(null);}}};}/*** 分析1：WorkerRunnable类的构造函数*/private static abstract class WorkerRunnable<Params, Result> implements Callable<Result> {// 此处的Callable也是任务；// 与Runnable的区别：Callable<T>存在返回值 = 其泛型Params[] mParams;}/*** 分析2：FutureTask类的构造函数* 定义：1个包装任务的包装类* 注：内部包含Callable<T> 、增加了一些状态标识 & 操作Callable<T>的接口*/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）的对象// ->>分析2exec.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();}}// 分析3protected 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+1private static final int MAXIMUM_POOL_SIZE = CPU_COUNT * 2 + 1;//设置线程池空闲线程存活时间30sprivate 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 最大容量为128private static final BlockingQueue<Runnable> sPoolWorkQueue =new LinkedBlockingQueue<Runnable>(128);// 步骤2： 根据参数配置执行任务线程池，即 THREAD_POOL_EXECUTORpublic static final Executor THREAD_POOL_EXECUTOR;static {ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(CORE_POOL_SIZE, MAXIMUM_POOL_SIZE, KEEP_ALIVE_SECONDS, TimeUnit.SECONDS,sPoolWorkQueue, sThreadFactory);// 设置核心线程池的 超时时间也为30sthreadPoolExecutor.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 ->>分析1postResult(result); }return result;}};.....// 省略}
/**
* 分析1：postResult(result)
*/private Result postResult(Result result) {@SuppressWarnings("unchecked")// 创建Handler对象 ->> 源自InternalHandler类—>>分析2Message 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（）必须在主线程使用}@Overridepublic 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]); ->>分析3break;// 若收到的消息 = 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的状态变更为：FINISHEDmStatus = 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() ) {@Overridepublic 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"><TextViewandroid:id="@+id/text1"android:layout_centerInParent="true"android:layout_width="wrap_content"android:layout_height="wrap_content"android:text="测试结果" /><Buttonandroid: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 + 显示我爱学习"/><Buttonandroid: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 + 显示我不爱学习"/><Buttonandroid: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;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);// 显示文本text = (TextView) findViewById(R.id.text1);// 创建与主线程关联的HandlermainHandler = 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){// 消息1case 1:try {//延时操作Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}// 通过主线程Handler.post方法进行在主线程的UI更新操作mainHandler.post(new Runnable() {@Overridepublic void run () {text.setText("我爱学习");}});break;// 消息2case 2:try {Thread.sleep(3000);} catch (InterruptedException e) {e.printStackTrace();}mainHandler.post(new Runnable() {@Overridepublic void run () {text.setText("我不喜欢学习");}});break;default:break;}}};/*** 步骤4：使用工作线程Handler向工作线程的消息队列发送消息* 在工作线程中，当消息循环时取出对应消息 & 在工作线程执行相关操作*/// 点击Button1button1 = (Button) findViewById(R.id.button1);button1.setOnClickListener(new View.OnClickListener() {@Overridepublic void onClick(View v) {// 通过sendMessage（）发送// a. 定义要发送的消息Message msg = Message.obtain();msg.what = 1; //消息的标识msg.obj = "A"; // 消息的存放// b. 通过Handler发送消息到其绑定的消息队列workHandler.sendMessage(msg);}});// 点击Button2button2 = (Button) findViewById(R.id.button2);button2.setOnClickListener(new View.OnClickListener() {@Overridepublic 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() {@Overridepublic 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() ) {@Overridepublic 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; // 当前线程idLooper 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（）*/ @Overridepublic void run() {// 1. 获得当前线程的idmTid = 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() ) {@Overridepublic boolean handleMessage(Message msg) {...//消息处理return true;}});/*** 源码分析：handlerThread.getLooper()* 作用：获得当前HandlerThread线程中的Looper对象*/ public Looper getLooper() {// 若线程不是存活的，则直接返回nullif (!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实现 耗时任务 操作**/  @Overrideprotected 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;}}@Overridepublic void onCreate() {Log.i("myIntentService", "onCreate");super.onCreate();}/** * 复写onStartCommand()方法* 默认实现 = 将请求的Intent添加到工作队列里**/  @Overridepublic int onStartCommand(Intent intent, int flags, int startId) {Log.i("myIntentService", "onStartCommand");return super.onStartCommand(intent, flags, startId);}@Overridepublic 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 {@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);// 同一服务只会开启1个工作线程// 在onHandleIntent（）函数里，依次处理传入的Intent请求// 将请求通过Bundle对象传入到Intent，再传入到服务里// 请求1Intent i = new Intent("cn.scu.finch");Bundle bundle = new Bundle();bundle.putString("taskName", "task1");i.putExtras(bundle);startService(i);// 请求2Intent 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，内部封装了 LooperHandlerThread thread = new HandlerThread("IntentService[" + mName + "]");thread.start();// 2. 获得工作线程的 Looper & 维护自己的工作队列mServiceLooper = thread.getLooper();// 3. 新建mServiceHandler & 绑定上述获得Looper// 新建的Handler 属于工作线程 ->>分析1mServiceHandler = new ServiceHandler(mServiceLooper);
}/** * 分析1：ServiceHandler源码分析**/ private final class ServiceHandler extends Handler {// 构造函数public ServiceHandler(Looper looper) {super(looper);}// IntentService的handleMessage（）把接收的消息交给onHandleIntent()处理@Overridepublic void handleMessage(Message msg) {// onHandleIntent 方法在工作线程中执行// onHandleIntent() = 抽象方法，使用时需重写 ->>分析2onHandleIntent((Intent)msg.obj);// 执行完调用 stopSelf() 结束服务stopSelf(msg.arg1);}
}/** * 分析2： onHandleIntent()源码分析* onHandleIntent() = 抽象方法，使用时需重写**/ @WorkerThreadprotected abstract void onHandleIntent(Intent intent);
问题2：IntentService 如何通过onStartCommand() 将Intent 传递给服务 & 依次插入到工作队列中/** * onStartCommand（）源码分析* onHandleIntent() = 抽象方法，使用时需重写**/ public int onStartCommand(Intent intent, int flags, int startId) {// 调用onStart（）->>分析1onStart(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) 里传入的 Intentmsg.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