全面详解Android实现多线程的几种方式（史上最全，最详细）

一、前言

Android多线程实现方式包括：

1、基础使用

• 继承Thread类
• 实现Runnable接口
• Handler

2、复合使用

• AsyncTask
• HandlerThread
• IntentService

3、高级使用

• 线程池（ThreadPool）

接下来对这几种实现多线程的方式进行全面 讲解。

二、基础使用

Android多线程实现的基础使用包括：

• 继承Thread类
• 实现Runnable接口
• Handler

接下来对各个进行分析。

1、继承Thread类

1.1 简介

1.2 使用详解

 // 步骤1：创建线程类 （继承自Thread类） class MyThread extends Thread{ 
    // 步骤2：复写run（），内容 = 定义线程行为 @Override public void run(){ 
    ... // 定义的线程行为 } } // 步骤3：创建线程对象，即 实例化线程类 MyThread mt=new MyThread(“线程名称”); // 步骤4：通过 线程对象 控制线程的状态，如 运行、睡眠、挂起 / 停止 // 此处采用 start（）开启线程 mt.start(); 

// 步骤1：采用匿名类，直接 创建 线程类的实例 new Thread("线程名称") { 
    // 步骤2：复写run（），内容 = 定义线程行为 @Override public void run() { 
    // 步骤3：通过 线程对象 控制线程的状态，如 运行、睡眠、挂起 / 停止  }.start(); 

1.3 实例应用

实例

• 应用场景：创建两个线程-实现两个不同的耗时任务
• 实例说明：实现2个窗口同时卖火车票；每个窗口卖100张，但卖票速度不同：窗口1是1s/张，窗口2是3s/张

<?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.4 与“实现Runnable接口”对比

2、实现Runnable接口

2.1 简介

2.2 使用详情

• 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(); 

 // 步骤1：通过匿名类 直接 创建线程辅助对象，即 实例化 线程辅助类 Runnable mt = new Runnable() { 
    // 步骤2：复写run（），定义线程行为 @Override public void run() { 
    } }; // 步骤3：创建线程对象，即 实例化线程类；线程类 = Thread类； Thread mt1 = new Thread(mt, "窗口1"); // 步骤4：通过 线程对象 控制线程的状态，如 运行、睡眠、挂起 / 停止 mt1.start(); 

2.3 实例应用

实例

• 应用场景：创建两个线程-实现一个耗时任务
• 实例说明：实现2个窗口同时卖火车票；两个窗口一共卖100张，卖票速度均为1s/张

<?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(); } }); } } 

3、 Handler

3.1 作用

3.2 意义

问：为什么要用 Handler消息传递机制
答：多个线程并发更新UI的同时 保证线程安全
具体描述如下：

3.4 相关概念

关于 Handler 异步通信机制中的相关概念如下：

3.5 使用方式

• 方式1：使用 Handler.sendMessage（）

 / * 方式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个步骤：

线程（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 源码分析

下面的源码分析将依据上述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对象

• 根据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次发送方式的判断：

步骤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()处理消息 

总结

• 根据操作步骤的源码分析总结
  
  
  
• 工作流程总结
  下面，将顺着文章：工作流程再理一次
  
  方式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实例

/ * 具体使用 */ 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（）

总结

• 根据操作步骤的源码分析总结
  
  
  
• 工作流程总结

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类

2. 原因讲解

2.1 储备知识

• 主线程的Looper对象的生命周期 = 该应用程序的生命周期
• 在Java中，非静态内部类 & 匿名内部类都默认持有 外部类的引用

• 上述的Handler实例的消息队列有2个分别来自线程1、2的消息（分别 为延迟1s、6s）
• 在Handler消息队列 还有未处理的消息 / 正在处理消息时，消息队列中的Message持有Handler实例的引用
• 由于Handler = 非静态内部类 / 匿名内部类（2种使用方式），故又默认持有外部类的引用（即MainActivity实例），引用关系如下图
  上述的引用关系会一直保持，直到Handler消息队列中的所有消息被处理完毕
  

  
  
  
  

• 在Handler消息队列 还有未处理的消息 / 正在处理消息时，此时若需销毁外部类MainActivity，但由于上述引用关系，垃圾回收器（GC）无法回收MainActivity，从而造成内存泄漏。如下图：
  
  2.3 总结

  
  
  
  

• 当Handler消息队列 还有未处理的消息 / 正在处理消息时，存在引用关系： “未被处理 / 正处理的消息 -> Handler实例 -> 外部类”
• 若出现 Handler的生命周期 > 外部类的生命周期 时（即 Handler消息队列 还有未处理的消息 / 正在处理消息 而 外部类需销毁时），将使得外部类无法被垃圾回收器（GC）回收，从而造成 内存泄露

3. 解决方案
   从上面可看出，造成内存泄露的原因有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 用于异步通信
  
  

• 类定义
  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的子类 } 

• 核心方法

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更新操作

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. 

• 当你连续点击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源码的分析完毕。

总结

3.IntentService

3.1 定义

Android里的一个封装类，继承四大组件之一的Service

3.2 作用

处理异步请求 & 实现多线程

3.3 使用场景

线程任务 需 按顺序、在后台执行

• 最常见的场景：离线下载
• 不符合多个数据同时请求的场景：所有的任务都在同一个Thread looper里执行

3.4 使用步骤

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