一、前言
Android多线程实现方式包括:
1、基础使用
- 继承Thread类
- 实现Runnable接口
- Handler
2、复合使用
- AsyncTask
- HandlerThread
- IntentService
3、高级使用
- 线程池(ThreadPool)
接下来对这几种实现多线程的方式进行全面 讲解。
二、基础使用
Android多线程实现的基础使用包括:
- 继承Thread类
- 实现Runnable接口
- Handler
接下来对各个进行分析。
1、继承Thread类
1.1 简介
1.2 使用详解
(1)使用步骤
(2) 具体使用
// 步骤1:创建线程类 (继承自Thread类)
class MyThread extends Thread{
// 步骤2:复写run(),内容 = 定义线程行为
@Override
public void run(){
... // 定义的线程行为}
}
// 步骤3:创建线程对象,即 实例化线程类
MyThread mt=new MyThread(“线程名称”);
// 步骤4:通过 线程对象 控制线程的状态,如 运行、睡眠、挂起 / 停止
// 此处采用 start()开启线程
mt.start();
(3) 简便使用:匿名类
很多情况下,开发者会选择一种更加方便的方法去创建线程:匿名类
// 步骤1:采用匿名类,直接 创建 线程类的实例
new Thread("线程名称") {
// 步骤2:复写run(),内容 = 定义线程行为
@Override
public void run() {
// 步骤3:通过 线程对象 控制线程的状态,如 运行、睡眠、挂起 / 停止
}.start();
上述两种使用方法本质相同,但是各有优劣势 & 不同的应用场景:
1.3 实例应用
实例
- 应用场景:创建两个线程-实现两个不同的耗时任务
- 实例说明:实现2个窗口同时卖火车票;每个窗口卖100张,但卖票速度不同:窗口1是1s/张,窗口2是3s/张
具体实现
main_activity.xml
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"tools:context="com.example.carson_ho.demoforthread_2.MainActivity">
//设置一个按钮以启动卖票
<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="点击开始卖票" />
</RelativeLayout>
MainActivity.java
package com.example.carson_ho.demoforthread_2;import androidos.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
public class MainActivity extends AppCompatActivity {
//主布局中定义了一个按钮用以启动线程
Button button;
//步骤1:创建线程类,继承自Thread类
//因为这里需要有两个操作:一个窗口卖票速度是1s/张,一个窗口是3s/张
//所以需要创建两个Thread的子类
//第一个Thread子类实现一个窗口卖票速度是1s/张
private class MyThread1 extends Thread{
private int ticket = 100;//一个窗口有100张票
private String name; //窗口名, 也即是线程的名字
public MyThread1(String name){
this.name=name;
}
//在run方法里复写需要进行的操作:卖票速度是1s/张
@Override
public void run(){
while (ticket>0){
ticket--;
System.out.println(name + "卖掉了1张票,剩余票数为:"+ticket);
try {
Thread.sleep(1000);//卖票速度是1s一张
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
//第二个Thread子类实现一个窗口卖票速度是3s/张
private class MyThread2 extends Thread{
private int ticket = 100;//一个窗口有100张票
private String name; //窗口名, 也即是线程的名字
public MyThread2(String name){
this.name=name;
}
//在run方法里复写需要进行的操作:卖票速度是3s/张
@Override
public void run(){
while (ticket>0){
ticket--;
System.out.println(name + "卖掉了1张票,剩余票数为:"+ticket);
try {
Thread.sleep(3000);//卖票速度是1s一张
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//Button按下时会开启一个新线程执行卖票
button = (Button) findViewById(R.id.button);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//步骤2:创建线程类的实例
//创建二个线程,模拟二个窗口卖票
MyThread1 mt1 = new MyThread1("窗口1");
MyThread2 mt2 = new MyThread2("窗口2");
//步骤3:调用start()方法开启线程
//启动二个线程,也即是窗口,开始卖票
mt1.start();
mt2.start();
}
});
}
}
测试结果
由于卖票速度不同,所以窗口1卖3张时,窗口2才卖1张。
1.4 与“实现Runnable接口”对比
在Java中,继承 Thread类和实现Runnable接口是实现多线程最常用的2种方法
今天我们就来对比下这两种方法
2、实现Runnable接口
2.1 简介
2.2 使用详情
(1)使用步骤
特别注意:
- Java中真正能创建新线程的只有Thread类对象
- 通过实现Runnable的方式,最终还是通过Thread类对象来创建线程
- 所以对于 实现了Runnable接口的类,称为 线程辅助类;Thread类才是真正的线程类
(2) 具体使用
// 步骤1:创建线程辅助类,实现Runnable接口
class MyThread implements Runnable{
....
@Override
// 步骤2:复写run(),定义线程行为
public void run(){
}
}
// 步骤3:创建线程辅助对象,即 实例化 线程辅助类
MyThread mt=new MyThread();
// 步骤4:创建线程对象,即 实例化线程类;线程类 = Thread类;
// 创建时通过Thread类的构造函数传入线程辅助类对象
// 原因:Runnable接口并没有任何对线程的支持,我们必须创建线程类(Thread类)的实例,从Thread类的一个实例内部运行
Thread td=new Thread(mt);
// 步骤5:通过 线程对象 控制线程的状态,如 运行、睡眠、挂起 / 停止
// 当调用start()方法时,线程对象会自动回调线程辅助类对象的run(),从而实现线程操作
td.start();
(3) 简便使用:匿名类
很多情况下,开发者会选择一种更加方便的方法去创建线程:匿名类
// 步骤1:通过匿名类 直接 创建线程辅助对象,即 实例化 线程辅助类
Runnable mt = new Runnable() {
// 步骤2:复写run(),定义线程行为
@Override
public void run() {
}
};
// 步骤3:创建线程对象,即 实例化线程类;线程类 = Thread类;
Thread mt1 = new Thread(mt, "窗口1");
// 步骤4:通过 线程对象 控制线程的状态,如 运行、睡眠、挂起 / 停止
mt1.start();
以上2种方法本质相同,但是各有优劣势 & 不同的应用场景:
2.3 实例应用
实例
- 应用场景:创建两个线程-实现一个耗时任务
- 实例说明:实现2个窗口同时卖火车票;两个窗口一共卖100张,卖票速度均为1s/张
具体实现
main_activity.xml
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context="com.example.carson_ho.demoforrunnable3.MainActivity">
//设置按钮用以启动线程
<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="点击开始卖票" />
</RelativeLayout>
MainActivity.java
package com.example.carson_ho.demoforrunnable3;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
public class MainActivity extends AppCompatActivity {
//主布局中定义了一个按钮用以启动线程
Button button;
//步骤1:创建线程类,实现Runnable接口
private class MyThread1 implements Runnable{
private int ticket = 100;//两个窗口一共要卖100张票
//在run方法里复写需要进行的操作:卖票速度1s/张
@Override
public void run(){
while (ticket>0){
ticket--;
System.out.println(Thread.currentThread().getName() + "卖掉了1张票,剩余票数为:"+ticket);
try {
Thread.sleep(1000);//卖票速度是1s一张
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//Button按下时会开启一个新线程执行卖票
button = (Button) findViewById(R.id.button);
button.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
//步骤2:创建线程类的实例
//因为是两个窗口共卖100张票,即共用资源
//所以只实例化一个实现了Runnable接口的类
MyThread1 mt = new MyThread1();
//因为要创建二个线程,模拟二个窗口卖票
Thread mt11 = new Thread(mt, "窗口1");
Thread mt12 = new Thread(mt, "窗口2");
//步骤3:调用start()方法开启线程
//启动二个线程,也即是窗口,开始卖票
mt11.start();
mt12.start();
}
});
}
}
测试结果
实现了两个窗口一起卖100张票的目的
3、 Handler
3.1 作用
在多线程的应用场景中,将工作线程中需更新UI的操作信息 传递到 UI主线程,从而实现 工作线程对UI的更新处理,最终实现异步消息的处理
3.2 意义
问:为什么要用 Handler
消息传递机制
答:多个线程并发更新UI的同时 保证线程安全
具体描述如下:
3.4 相关概念
关于 Handler 异步通信机制中的相关概念如下:
在下面的讲解中,我将直接使用英文名讲解,即 Handler、Message、Message Queue、Looper,希望大家先熟悉相关概念
3.5 使用方式
Handler的使用方式 因发送消息到消息队列的方式不同而不同
共分为2种:使用Handler.sendMessage()、使用Handler.post()
- 方式1:使用 Handler.sendMessage()
在该使用方式中,又分为2种:新建Handler子类(内部类)、匿名 Handler子类
但本质相同,即 继承了Handler类 & 创建了子类
/**
* 方式1:新建Handler子类(内部类)
*/
// 步骤1:自定义Handler子类(继承Handler类) & 复写handleMessage()方法
class mHandler extends Handler {
// 通过复写handlerMessage() 从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
...// 需执行的UI操作
}
}
// 步骤2:在主线程中创建Handler实例
private Handler mhandler = new mHandler();
// 步骤3:创建所需的消息对象
Message msg = Message.obtain(); // 实例化消息对象
msg.what = 1; // 消息标识
msg.obj = "AA"; // 消息内容存放
// 步骤4:在工作线程中 通过Handler发送消息到消息队列中
// 可通过sendMessage() / post()
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
mHandler.sendMessage(msg);
// 步骤5:开启工作线程(同时启动了Handler)
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
/**
* 方式2:匿名内部类
*/
// 步骤1:在主线程中 通过匿名内部类 创建Handler类对象
private Handler mhandler = new Handler(){
// 通过复写handlerMessage()从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
...// 需执行的UI操作
}
};
// 步骤2:创建消息对象
Message msg = Message.obtain(); // 实例化消息对象
msg.what = 1; // 消息标识
msg.obj = "AA"; // 消息内容存放
// 步骤3:在工作线程中 通过Handler发送消息到消息队列中
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
mHandler.sendMessage(msg);
// 步骤4:开启工作线程(同时启动了Handler)
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
- 方式2:使用Handler.post()
// 步骤1:在主线程中创建Handler实例 private Handler mhandler = new mHandler(); // 步骤2:在工作线程中 发送消息到消息队列中 & 指定操作UI内容 // 需传入1个Runnable对象 mHandler.post(new Runnable() { @Override public void run() { ... // 需执行的UI操作 } }); // 步骤3:开启工作线程(同时启动了Handler) // 多线程可采用AsyncTask、继承Thread类、实现Runnable
3.6 实例讲解
本文将用实例逐个讲解 Handler的用法
注:
- 由于Handler的作用 = 将工作线程需操作UI的消息 传递 到主线程,使得主线程可根据工作线程的需求
- 更新UI,从而避免线程操作不安全的问题 故下文的实例 = 1个简单 “更新UI操作” 的案例
- 主布局文件相同 = 1个用于展示的TextView,具体如下:
布局代码:activity_main.xml
<?xml version="1.0" encoding="utf-8"?> <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" android:gravity="center" tools:context="com.example.carson_ho.handler_learning.MainActivity"> <TextView android:id="@+id/show" android:layout_width="wrap_content" android:layout_height="wrap_content" android:text="" /> </RelativeLayout>
(1) 使用 Handler.sendMessage()
方式1:新建Handler子类(内部类)
- 具体使用
public class MainActivity extends AppCompatActivity { public TextView mTextView; public Handler mHandler; // 步骤1:(自定义)新创建Handler子类(继承Handler类) & 复写handleMessage()方法 class Mhandler extends Handler { // 通过复写handlerMessage() 从而确定更新UI的操作 @Override public void handleMessage(Message msg) { // 根据不同线程发送过来的消息,执行不同的UI操作 // 根据 Message对象的what属性 标识不同的消息 switch (msg.what) { case 1: mTextView.setText("执行了线程1的UI操作"); break; case 2: mTextView.setText("执行了线程2的UI操作"); break; } } } @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); mTextView = (TextView) findViewById(R.id.show); // 步骤2:在主线程中创建Handler实例 mHandler = new Mhandler(); // 采用继承Thread类实现多线程演示 new Thread() { @Override public void run() { try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } // 步骤3:创建所需的消息对象 Message msg = Message.obtain(); msg.what = 1; // 消息标识 msg.obj = "A"; // 消息内存存放 // 步骤4:在工作线程中 通过Handler发送消息到消息队列中 mHandler.sendMessage(msg); } }.start(); // 步骤5:开启工作线程(同时启动了Handler) // 此处用2个工作线程展示 new Thread() { @Override public void run() { try { Thread.sleep(6000); } catch (InterruptedException e) { e.printStackTrace(); } // 通过sendMessage()发送 // a. 定义要发送的消息 Message msg = Message.obtain(); msg.what = 2; //消息的标识 msg.obj = "B"; // 消息的存放 // b. 通过Handler发送消息到其绑定的消息队列 mHandler.sendMessage(msg); } }.start(); } }
方式2:匿名内部类
- 具体使用
public class MainActivity extends AppCompatActivity { public TextView mTextView; public Handler mHandler; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); mTextView = (TextView) findViewById(R.id.show); // 步骤1:在主线程中 通过匿名内部类 创建Handler类对象 mHandler = new Handler(){ // 通过复写handlerMessage()从而确定更新UI的操作 @Override public void handleMessage(Message msg) { // 根据不同线程发送过来的消息,执行不同的UI操作 switch (msg.what) { case 1: mTextView.setText("执行了线程1的UI操作"); break; case 2: mTextView.setText("执行了线程2的UI操作"); break; } } }; // 采用继承Thread类实现多线程演示 new Thread() { @Override public void run() { try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } // 步骤3:创建所需的消息对象 Message msg = Message.obtain(); msg.what = 1; // 消息标识 msg.obj = "A"; // 消息内存存放 // 步骤4:在工作线程中 通过Handler发送消息到消息队列中 mHandler.sendMessage(msg); } }.start(); // 步骤5:开启工作线程(同时启动了Handler) // 此处用2个工作线程展示 new Thread() { @Override public void run() { try { Thread.sleep(6000); } catch (InterruptedException e) { e.printStackTrace(); } // 通过sendMessage()发送 // a. 定义要发送的消息 Message msg = Message.obtain(); msg.what = 2; //消息的标识 msg.obj = "B"; // 消息的存放 // b. 通过Handler发送消息到其绑定的消息队列 mHandler.sendMessage(msg); } }.start(); } }
(2) 使用 Handler.post()
- 具体使用
public class MainActivity extends AppCompatActivity { public TextView mTextView; public Handler mHandler; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); mTextView = (TextView) findViewById(R.id.show); // 步骤1:在主线程中创建Handler实例 mHandler = new Handler(); // 步骤2:在工作线程中 发送消息到消息队列中 & 指定操作UI内容 new Thread() { @Override public void run() { try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } // 通过psot()发送,需传入1个Runnable对象 mHandler.post(new Runnable() { @Override public void run() { // 指定操作UI内容 mTextView.setText("执行了线程1的UI操作"); } }); } }.start(); // 步骤3:开启工作线程(同时启动了Handler) // 此处用2个工作线程展示 new Thread() { @Override public void run() { try { Thread.sleep(6000); } catch (InterruptedException e) { e.printStackTrace(); } mHandler.post(new Runnable() { @Override public void run() { mTextView.setText("执行了线程2的UI操作"); } }); } }.start(); } }
3.7 工作原理 解析
(1)工作流程解析
Handler机制的工作流程主要包括4个步骤:异步通信准备
消息发送
消息循环
消息处理具体如下图:
(2)工作流程图
(3) 示意图
(4) 特别注意线程(Thread)、循环器(Looper)、处理者(Handler)之间的对应关系如下:
- 1个线程(Thread)只能绑定 1个循环器(Looper),但可以有多个处理者(Handler)
- 1个循环器(Looper) 可绑定多个处理者(Handler)
- 1个处理者(Handler) 只能绑定1个1个循环器(Looper)
3.8 Handler机制的核心类
在源码分析前,先来了解Handler机制中的核心类
(1) 类说明
Handler机制 中有3个重要的类:
- 处理器 类(Handler)
- 消息队列 类(MessageQueue)
- 循环器 类(Looper)
(2) 类图
(3) 具体介绍
3.9 源码分析
下面的源码分析将根据 Handler的使用步骤进行
Handler使用方式 因发送消息到消息队列的方式不同而不同,共分为2种:使用Handler.sendMessage()、使用Handler.post()
下面的源码分析将依据上述2种使用方式进行
方式1:使用 Handler.sendMessage()
- 使用步骤
/**
* 此处以 匿名内部类 的使用方式为例
*/
// 步骤1:在主线程中 通过匿名内部类 创建Handler类对象
private Handler mhandler = new Handler(){
// 通过复写handlerMessage()从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
...// 需执行的UI操作
}
};
// 步骤2:创建消息对象
Message msg = Message.obtain(); // 实例化消息对象
msg.what = 1; // 消息标识
msg.obj = "AA"; // 消息内容存放
// 步骤3:在工作线程中 通过Handler发送消息到消息队列中
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
mHandler.sendMessage(msg);
// 步骤4:开启工作线程(同时启动了Handler)
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
- 源码分析
下面,我将根据上述每个步骤进行源码分析
步骤1:在主线程中 通过匿名内部类 创建Handler类对象
/**
* 具体使用
*/
private Handler mhandler = new Handler(){
// 通过复写handlerMessage()从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
...// 需执行的UI操作
}
};
/**
* 源码分析:Handler的构造方法
* 作用:初始化Handler对象 & 绑定线程
* 注:
* a. Handler需绑定 线程才能使用;绑定后,Handler的消息处理会在绑定的线程中执行
* b. 绑定方式 = 先指定Looper对象,从而绑定了 Looper对象所绑定的线程(因为Looper对象本已绑定了对应线程)
* c. 即:指定了Handler对象的 Looper对象 = 绑定到了Looper对象所在的线程
*/
public Handler() {
this(null, false);
// ->>分析1
}
/**
* 分析1:this(null, false) = Handler(null,false)
*/
public Handler(Callback callback, boolean async) {
...// 仅贴出关键代码
// 1. 指定Looper对象
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
// Looper.myLooper()作用:获取当前线程的Looper对象;若线程无Looper对象则抛出异常
// 即 :若线程中无创建Looper对象,则也无法创建Handler对象
// 故 若需在子线程中创建Handler对象,则需先创建Looper对象
// 注:可通过Loop.getMainLooper()可以获得当前进程的主线程的Looper对象
// 2. 绑定消息队列对象(MessageQueue)
mQueue = mLooper.mQueue;
// 获取该Looper对象中保存的消息队列对象(MessageQueue)
// 至此,保证了handler对象 关联上 Looper对象中MessageQueue
}
从上面可看出:
-
当创建Handler对象时,则通过 构造方法 自动关联当前线程的Looper对象 & 对应的消息队列对象(MessageQueue),从而 自动绑定了 实现创建Handler对象操作的线程
-
那么,当前线程的Looper对象 & 对应的消息队列对象(MessageQueue) 是什么时候创建的呢?
在上述使用步骤中,并无 创建Looper对象 & 对应的消息队列对象(MessageQueue)这1步
步骤1前的隐式操作1:创建循环器对象(Looper) & 消息队列对象(MessageQueue)
-
步骤介绍
-
源码分析
/**
* 源码分析1:Looper.prepare()
* 作用:为当前线程(子线程) 创建1个循环器对象(Looper),同时也生成了1个消息队列对象(MessageQueue)
* 注:需在子线程中手动调用该方法
*/
public static final void prepare() {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
// 1. 判断sThreadLocal是否为null,否则抛出异常
//即 Looper.prepare()方法不能被调用两次 = 1个线程中只能对应1个Looper实例
// 注:sThreadLocal = 1个ThreadLocal对象,用于存储线程的变量
sThreadLocal.set(new Looper(true));
// 2. 若为初次Looper.prepare(),则创建Looper对象 & 存放在ThreadLocal变量中
// 注:Looper对象是存放在Thread线程里的
// 源码分析Looper的构造方法->>分析a
}
/**
* 分析a:Looper的构造方法
**/
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
// 1. 创建1个消息队列对象(MessageQueue)
// 即 当创建1个Looper实例时,会自动创建一个与之配对的消息队列对象(MessageQueue)
mRun = true;
mThread = Thread.currentThread();
}
/**
* 源码分析2:Looper.prepareMainLooper()
* 作用:为 主线程(UI线程) 创建1个循环器对象(Looper),同时也生成了1个消息队列对象(MessageQueue)
* 注:该方法在主线程(UI线程)创建时自动调用,即 主线程的Looper对象自动生成,不需手动生成
*/
// 在Android应用进程启动时,会默认创建1个主线程(ActivityThread,也叫UI线程)
// 创建时,会自动调用ActivityThread的1个静态的main()方法 = 应用程序的入口
// main()内则会调用Looper.prepareMainLooper()为主线程生成1个Looper对象
/**
* 源码分析:main()
**/
public static void main(String[] args) {
... // 仅贴出关键代码
Looper.prepareMainLooper();
// 1. 为主线程创建1个Looper对象,同时生成1个消息队列对象(MessageQueue)
// 方法逻辑类似Looper.prepare()
// 注:prepare():为子线程中创建1个Looper对象
ActivityThread thread = new ActivityThread();
// 2. 创建主线程
Looper.loop();
// 3. 自动开启 消息循环 ->>下面将详细分析
}
总结:
- 创建主线程时,会自动调用ActivityThread的1个静态的main();而main()内则会调用Looper.prepareMainLooper()为主线程生成1个Looper对象,同时也会生成其对应的MessageQueue对象
(1)即 主线程的Looper对象自动生成,不需手动生成;而子线程的Looper对象则需手动通过Looper.prepare()创建
(2)在子线程若不手动创建Looper对象 则无法生成Handler对象
-
根据Handler的作用(在主线程更新UI),故Handler实例的创建场景 主要在主线程
-
生成Looper & MessageQueue对象后,则会自动进入消息循环:Looper.loop(),即又是另外一个隐式操作。
步骤1前的隐式操作2:消息循环
此处主要分析的是Looper类中的loop()方法
/** * 源码分析: Looper.loop() * 作用:消息循环,即从消息队列中获取消息、分发消息到Handler * 特别注意: * a. 主线程的消息循环不允许退出,即无限循环 * b. 子线程的消息循环允许退出:调用消息队列MessageQueue的quit() */ public static void loop() { ...// 仅贴出关键代码 // 1. 获取当前Looper的消息队列 final Looper me = myLooper(); if (me == null) { throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread."); } // myLooper()作用:返回sThreadLocal存储的Looper实例;若me为null 则抛出异常 // 即loop()执行前必须执行prepare(),从而创建1个Looper实例 final MessageQueue queue = me.mQueue; // 获取Looper实例中的消息队列对象(MessageQueue) // 2. 消息循环(通过for循环) for (;;) { // 2.1 从消息队列中取出消息 Message msg = queue.next(); if (msg == null) { return; } // next():取出消息队列里的消息 // 若取出的消息为空,则线程阻塞 // ->> 分析1 // 2.2 派发消息到对应的Handler msg.target.dispatchMessage(msg); // 把消息Message派发给消息对象msg的target属性 // target属性实际是1个handler对象 // ->>分析2 // 3. 释放消息占据的资源 msg.recycle(); } } /** * 分析1:queue.next() * 定义:属于消息队列类(MessageQueue)中的方法 * 作用:出队消息,即从 消息队列中 移出该消息 */ Message next() { ...// 仅贴出关键代码 // 该参数用于确定消息队列中是否还有消息 // 从而决定消息队列应处于出队消息状态 or 等待状态 int nextPollTimeoutMillis = 0; for (;;) { if (nextPollTimeoutMillis != 0) { Binder.flushPendingCommands(); } // nativePollOnce方法在native层,若是nextPollTimeoutMillis为-1,此时消息队列处于等待状态 nativePollOnce(ptr, nextPollTimeoutMillis); synchronized (this) { final long now = SystemClock.uptimeMillis(); Message prevMsg = null; Message msg = mMessages; // 出队消息,即 从消息队列中取出消息:按创建Message对象的时间顺序 if (msg != null) { if (now < msg.when) { nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE); } else { // 取出了消息 mBlocked = false; if (prevMsg != null) { prevMsg.next = msg.next; } else { mMessages = msg.next; } msg.next = null; if (DEBUG) Log.v(TAG, "Returning message: " + msg); msg.markInUse(); return msg; } } else { // 若 消息队列中已无消息,则将nextPollTimeoutMillis参数设为-1 // 下次循环时,消息队列则处于等待状态 nextPollTimeoutMillis = -1; } ...... } ..... } }// 回到分析原处 /** * 分析2:dispatchMessage(msg) * 定义:属于处理者类(Handler)中的方法 * 作用:派发消息到对应的Handler实例 & 根据传入的msg作出对应的操作 */ public void dispatchMessage(Message msg) { // 1. 若msg.callback属性不为空,则代表使用了post(Runnable r)发送消息 // 则执行handleCallback(msg),即回调Runnable对象里复写的run() // 上述结论会在讲解使用“post(Runnable r)”方式时讲解 if (msg.callback != null) { handleCallback(msg); } else { if (mCallback != null) { if (mCallback.handleMessage(msg)) { return; } } // 2. 若msg.callback属性为空,则代表使用了sendMessage(Message msg)发送消息(即此处需讨论的) // 则执行handleMessage(msg),即回调复写的handleMessage(msg) ->> 分析3 handleMessage(msg); } } /** * 分析3:handleMessage(msg) * 注:该方法 = 空方法,在创建Handler实例时复写 = 自定义消息处理方式 **/ public void handleMessage(Message msg) { ... // 创建Handler实例时复写 }
总结:
- 消息循环的操作 = 消息出队 + 分发给对应的Handler实例
- 分发给对应的Handler的过程:根据出队消息的归属者通过dispatchMessage(msg)进行分发,最终回调复写的handleMessage(Message msg),从而实现 消息处理 的操作
- 特别注意:在进行消息分发时(dispatchMessage(msg)),会进行1次发送方式的判断:
(1)若msg.callback属性不为空,则代表使用了post(Runnable r)发送消息,则直接回调Runnable对象里复写的run()
(2)若msg.callback属性为空,则代表使用了sendMessage(Message msg)发送消息,则回调复写的handleMessage(msg)
至此,关于步骤1的源码分析讲解完毕。总结如下
步骤2:创建消息对象
/** * 具体使用 */ Message msg = Message.obtain(); // 实例化消息对象 msg.what = 1; // 消息标识 msg.obj = "AA"; // 消息内容存放 /** * 源码分析:Message.obtain() * 作用:创建消息对象 * 注:创建Message对象可用关键字new 或 Message.obtain() */ public static Message obtain() { // Message内部维护了1个Message池,用于Message消息对象的复用 // 使用obtain()则是直接从池内获取 synchronized (sPoolSync) { if (sPool != null) { Message m = sPool; sPool = m.next; m.next = null; m.flags = 0; // clear in-use flag sPoolSize--; return m; } // 建议:使用obtain()”创建“消息对象,避免每次都使用new重新分配内存 } // 若池内无消息对象可复用,则还是用关键字new创建 return new Message(); }
总结
步骤3:在工作线程中 发送消息到消息队列中
多线程的实现方式:AsyncTask、继承Thread类、实现Runnable
/** * 具体使用 */ mHandler.sendMessage(msg); /** * 源码分析:mHandler.sendMessage(msg) * 定义:属于处理器类(Handler)的方法 * 作用:将消息 发送 到消息队列中(Message ->> MessageQueue) */ public final boolean sendMessage(Message msg) { return sendMessageDelayed(msg, 0); // ->>分析1 } /** * 分析1:sendMessageDelayed(msg, 0) **/ public final boolean sendMessageDelayed(Message msg, long delayMillis) { if (delayMillis < 0) { delayMillis = 0; } return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis); // ->> 分析2 } /** * 分析2:sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis) **/ public boolean sendMessageAtTime(Message msg, long uptimeMillis) { // 1. 获取对应的消息队列对象(MessageQueue) MessageQueue queue = mQueue; // 2. 调用了enqueueMessage方法 ->>分析3 return enqueueMessage(queue, msg, uptimeMillis); } /** * 分析3:enqueueMessage(queue, msg, uptimeMillis) **/ private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) { // 1. 将msg.target赋值为this // 即 :把 当前的Handler实例对象作为msg的target属性 msg.target = this; // 请回忆起上面说的Looper的loop()中消息循环时,会从消息队列中取出每个消息msg,然后执行msg.target.dispatchMessage(msg)去处理消息 // 实际上则是将该消息派发给对应的Handler实例 // 2. 调用消息队列的enqueueMessage() // 即:Handler发送的消息,最终是保存到消息队列->>分析4 return queue.enqueueMessage(msg, uptimeMillis); } /** * 分析4:queue.enqueueMessage(msg, uptimeMillis) * 定义:属于消息队列类(MessageQueue)的方法 * 作用:入队,即 将消息 根据时间 放入到消息队列中(Message ->> MessageQueue) * 采用单链表实现:提高插入消息、删除消息的效率 */ boolean enqueueMessage(Message msg, long when) { ...// 仅贴出关键代码 synchronized (this) { msg.markInUse(); msg.when = when; Message p = mMessages; boolean needWake; // 判断消息队列里有无消息 // a. 若无,则将当前插入的消息 作为队头 & 若此时消息队列处于等待状态,则唤醒 if (p == null || when == 0 || when < p.when) { msg.next = p; mMessages = msg; needWake = mBlocked; } else { needWake = mBlocked && p.target == null && msg.isAsynchronous(); Message prev; // b. 判断消息队列里有消息,则根据 消息(Message)创建的时间 插入到队列中 for (;;) { prev = p; p = p.next; if (p == null || when < p.when) { break; } if (needWake && p.isAsynchronous()) { needWake = false; } } msg.next = p; prev.next = msg; } if (needWake) { nativeWake(mPtr); } } return true; } // 之后,随着Looper对象的无限消息循环 // 不断从消息队列中取出Handler发送的消息 & 分发到对应Handler // 最终回调Handler.handleMessage()处理消息
总结
Handler发送消息的本质 = 为该消息定义target属性(即本身实例对象) & 将消息入队到绑定线程的消息队列中。具体如下:
至此,关于使用 Handler.sendMessage()的源码解析完毕
总结
-
根据操作步骤的源码分析总结
-
工作流程总结
下面,将顺着文章:工作流程再理一次
方式2:使用 Handler.post() -
使用步骤
// 步骤1:在主线程中创建Handler实例
private Handler mhandler = new mHandler();
// 步骤2:在工作线程中 发送消息到消息队列中 & 指定操作UI内容
// 需传入1个Runnable对象
mHandler.post(new Runnable() {
@Override
public void run() {
... // 需执行的UI操作
}
});
// 步骤3:开启工作线程(同时启动了Handler)
// 多线程可采用AsyncTask、继承Thread类、实现Runnable
- 源码分析
下面,我将根据上述每个步骤进行源码分析
实际上,该方式与方式1中的Handler.sendMessage()工作原理相同、源码分析类似,下面将主要讲解不同之处
步骤1:在主线程中创建Handler实例
/** * 具体使用 */ private Handler mhandler = new Handler(); // 与方式1的使用不同:此处无复写Handler.handleMessage() /** * 源码分析:Handler的构造方法 * 作用: * a. 在此之前,主线程创建时隐式创建Looper对象、MessageQueue对象 * b. 初始化Handler对象、绑定线程 & 进入消息循环 * 此处的源码分析类似方式1,此处不作过多描述 */
步骤2:在工作线程中 发送消息到消息队列中
/** * 具体使用 * 需传入1个Runnable对象、复写run()从而指定UI操作 */ mHandler.post(new Runnable() { @Override public void run() { ... // 需执行的UI操作 } }); /** * 源码分析:Handler.post(Runnable r) * 定义:属于处理者类(Handler)中的方法 * 作用:定义UI操作、将Runnable对象封装成消息对象 & 发送 到消息队列中(Message ->> MessageQueue) * 注: * a. 相比sendMessage(),post()最大的不同在于,更新的UI操作可直接在重写的run()中定义 * b. 实际上,Runnable并无创建新线程,而是发送 消息 到消息队列中 */ public final boolean post(Runnable r) { return sendMessageDelayed(getPostMessage(r), 0); // getPostMessage(r) 的源码分析->>分析1 // sendMessageDelayed()的源码分析 ->>分析2 } /** * 分析1:getPostMessage(r) * 作用:将传入的Runable对象封装成1个消息对象 **/ private static Message getPostMessage(Runnable r) { // 1. 创建1个消息对象(Message) Message m = Message.obtain(); // 注:创建Message对象可用关键字new 或 Message.obtain() // 建议:使用Message.obtain()创建, // 原因:因为Message内部维护了1个Message池,用于Message的复用,使用obtain()直接从池内获取,从而避免使用new重新分配内存 // 2. 将 Runable对象 赋值给消息对象(message)的callback属性 m.callback = r; // 3. 返回该消息对象 return m; } // 回到调用原处 /** * 分析2:sendMessageDelayed(msg, 0) * 作用:实际上,从此处开始,则类似方式1 = 将消息入队到消息队列, * 即 最终是调用MessageQueue.enqueueMessage() **/ public final boolean sendMessageDelayed(Message msg, long delayMillis) { if (delayMillis < 0) { delayMillis = 0; } return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis); // 请看分析3 } /** * 分析3:sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis) **/ public boolean sendMessageAtTime(Message msg, long uptimeMillis) { // 1. 获取对应的消息队列对象(MessageQueue) MessageQueue queue = mQueue; // 2. 调用了enqueueMessage方法 ->>分析3 return enqueueMessage(queue, msg, uptimeMillis); } /** * 分析4:enqueueMessage(queue, msg, uptimeMillis) **/ private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) { // 1. 将msg.target赋值为this // 即 :把 当前的Handler实例对象作为msg的target属性 msg.target = this; // 请回忆起上面说的Looper的loop()中消息循环时,会从消息队列中取出每个消息msg,然后执行msg.target.dispatchMessage(msg)去处理消息 // 实际上则是将该消息派发给对应的Handler实例 // 2. 调用消息队列的enqueueMessage() // 即:Handler发送的消息,最终是保存到消息队列 return queue.enqueueMessage(msg, uptimeMillis); } // 注:实际上从分析2开始,源码 与 sendMessage(Message msg)发送方式相同
从上面的分析可看出:
- 消息对象的创建 = 内部 根据Runnable对象而封装
- 发送到消息队列的逻辑 = 方式1中sendMessage(Message msg)
下面,我们重新回到步骤1前的隐式操作2:消息循环,即Looper类中的loop()方法
/** * 源码分析: Looper.loop() * 作用:消息循环,即从消息队列中获取消息、分发消息到Handler * 特别注意: * a. 主线程的消息循环不允许退出,即无限循环 * b. 子线程的消息循环允许退出:调用消息队列MessageQueue的quit() */ public static void loop() { ...// 仅贴出关键代码 // 1. 获取当前Looper的消息队列 final Looper me = myLooper(); if (me == null) { throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread."); } // myLooper()作用:返回sThreadLocal存储的Looper实例;若me为null 则抛出异常 // 即loop()执行前必须执行prepare(),从而创建1个Looper实例 final MessageQueue queue = me.mQueue; // 获取Looper实例中的消息队列对象(MessageQueue) // 2. 消息循环(通过for循环) for (;;) { // 2.1 从消息队列中取出消息 Message msg = queue.next(); if (msg == null) { return; } // next():取出消息队列里的消息 // 若取出的消息为空,则线程阻塞 // 2.2 派发消息到对应的Handler msg.target.dispatchMessage(msg); // 把消息Message派发给消息对象msg的target属性 // target属性实际是1个handler对象 // ->>分析1 // 3. 释放消息占据的资源 msg.recycle(); } } /** * 分析1:dispatchMessage(msg) * 定义:属于处理者类(Handler)中的方法 * 作用:派发消息到对应的Handler实例 & 根据传入的msg作出对应的操作 */ public void dispatchMessage(Message msg) { // 1. 若msg.callback属性不为空,则代表使用了post(Runnable r)发送消息(即此处需讨论的) // 则执行handleCallback(msg),即回调Runnable对象里复写的run()->> 分析2 if (msg.callback != null) { handleCallback(msg); } else { if (mCallback != null) { if (mCallback.handleMessage(msg)) { return; } } // 2. 若msg.callback属性为空,则代表使用了sendMessage(Message msg)发送消息(即此处需讨论的) // 则执行handleMessage(msg),即回调复写的handleMessage(msg) handleMessage(msg); } } /** * 分析2:handleCallback(msg) **/ private static void handleCallback(Message message) { message.callback.run(); // Message对象的callback属性 = 传入的Runnable对象 // 即回调Runnable对象里复写的run() }
至此,你应该明白使用 Handler.post()的工作流程:与方式1(Handler.sendMessage())类似,区别在于:
- 不需外部创建消息对象,而是内部根据传入的Runnable对象 封装消息对象
- 回调的消息处理方法是:复写Runnable对象的run()
二者的具体异同如下:
至此,关于使用 Handler.post()的源码解析完毕总结
- 根据操作步骤的源码分析总结
- 工作流程总结
下面,将顺着文章:工作流程再理一次
3.10 特别注意:Handle引起的内存泄漏
1. 问题描述
Handler的一般用法 = 新建Handler子类(内部类) 、匿名Handler内部类
/**
* 方式1:新建Handler子类(内部类)
*/
public class MainActivity extends AppCompatActivity {
public static final String TAG = "carson:";
private Handler showhandler;
// 主线程创建时便自动创建Looper & 对应的MessageQueue
// 之后执行Loop()进入消息循环
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//1. 实例化自定义的Handler类对象->>分析1
//注:此处并无指定Looper,故自动绑定当前线程(主线程)的Looper、MessageQueue
showhandler = new FHandler();
// 2. 启动子线程1
new Thread() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 1;// 消息标识
msg.obj = "AA";// 消息存放
// b. 传入主线程的Handler & 向其MessageQueue发送消息
showhandler.sendMessage(msg);
}
}.start();
// 3. 启动子线程2
new Thread() {
@Override
public void run() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 2;// 消息标识
msg.obj = "BB";// 消息存放
// b. 传入主线程的Handler & 向其MessageQueue发送消息
showhandler.sendMessage(msg);
}
}.start();
}
// 分析1:自定义Handler子类
class FHandler extends Handler {
// 通过复写handlerMessage() 从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
Log.d(TAG, "收到线程1的消息");
break;
case 2:
Log.d(TAG, " 收到线程2的消息");
break;
}
}
}
}
/**
* 方式2:匿名Handler内部类
*/
public class MainActivity extends AppCompatActivity {
public static final String TAG = "carson:";
private Handler showhandler;
// 主线程创建时便自动创建Looper & 对应的MessageQueue
// 之后执行Loop()进入消息循环
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//1. 通过匿名内部类实例化的Handler类对象
//注:此处并无指定Looper,故自动绑定当前线程(主线程)的Looper、MessageQueue
showhandler = new Handler(){
// 通过复写handlerMessage()从而确定更新UI的操作
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
Log.d(TAG, "收到线程1的消息");
break;
case 2:
Log.d(TAG, " 收到线程2的消息");
break;
}
}
};
// 2. 启动子线程1
new Thread() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 1;// 消息标识
msg.obj = "AA";// 消息存放
// b. 传入主线程的Handler & 向其MessageQueue发送消息
showhandler.sendMessage(msg);
}
}.start();
// 3. 启动子线程2
new Thread() {
@Override
public void run() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 2;// 消息标识
msg.obj = "BB";// 消息存放
// b. 传入主线程的Handler & 向其MessageQueue发送消息
showhandler.sendMessage(msg);
}
}.start();
}
}
测试结果
示意图
- 上述例子虽可运行成功,但代码会出现严重警告:
- 警告的原因 = 该Handler类由于无设置为 静态类,从而导致了内存泄露
- 最终的内存泄露发生在Handler类的外部类:MainActivity类
示意图
那么,该Handler在无设置为静态类时,为什么会造成内存泄露呢?
2. 原因讲解
2.1 储备知识
- 主线程的Looper对象的生命周期 = 该应用程序的生命周期
- 在Java中,非静态内部类 & 匿名内部类都默认持有 外部类的引用
2.2 泄露原因描述
从上述示例代码可知:
-
上述的Handler实例的消息队列有2个分别来自线程1、2的消息(分别 为延迟1s、6s)
-
在Handler消息队列 还有未处理的消息 / 正在处理消息时,消息队列中的Message持有Handler实例的引用
-
由于Handler = 非静态内部类 / 匿名内部类(2种使用方式),故又默认持有外部类的引用(即MainActivity实例),引用关系如下图
上述的引用关系会一直保持,直到Handler消息队列中的所有消息被处理完毕
-
在Handler消息队列 还有未处理的消息 / 正在处理消息时,此时若需销毁外部类MainActivity,但由于上述引用关系,垃圾回收器(GC)无法回收MainActivity,从而造成内存泄漏。如下图:
2.3 总结 -
当Handler消息队列 还有未处理的消息 / 正在处理消息时,存在引用关系: “未被处理 / 正处理的消息 -> Handler实例 -> 外部类”
-
若出现 Handler的生命周期 > 外部类的生命周期 时(即 Handler消息队列 还有未处理的消息 / 正在处理消息 而 外部类需销毁时),将使得外部类无法被垃圾回收器(GC)回收,从而造成 内存泄露
- 解决方案
从上面可看出,造成内存泄露的原因有2个关键条件:
- 存在“未被处理 / 正处理的消息 -> Handler实例 -> 外部类” 的引用关系
- Handler的生命周期 > 外部类的生命周期
- 即 Handler消息队列 还有未处理的消息 / 正在处理消息 而 外部类需销毁
解决方案的思路 = 使得上述任1条件不成立 即可。
解决方案1:静态内部类+弱引用
-
原理
静态内部类 不默认持有外部类的引用,从而使得 “未被处理 / 正处理的消息 -> Handler实例 -> 外部类” 的引用关系 的引用关系 不复存在。 -
具体方案
将Handler的子类设置成 静态内部类
- 同时,还可加上 使用WeakReference弱引用持有Activity实例
- 原因:弱引用的对象拥有短暂的生命周期。在垃圾回收器线程扫描时,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存
- 解决代码
public class MainActivity extends AppCompatActivity {
public static final String TAG = "carson:";
private Handler showhandler;
// 主线程创建时便自动创建Looper & 对应的MessageQueue
// 之后执行Loop()进入消息循环
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
//1. 实例化自定义的Handler类对象->>分析1
//注:
// a. 此处并无指定Looper,故自动绑定当前线程(主线程)的Looper、MessageQueue;
// b. 定义时需传入持有的Activity实例(弱引用)
showhandler = new FHandler(this);
// 2. 启动子线程1
new Thread() {
@Override
public void run() {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 1;// 消息标识
msg.obj = "AA";// 消息存放
// b. 传入主线程的Handler & 向其MessageQueue发送消息
showhandler.sendMessage(msg);
}
}.start();
// 3. 启动子线程2
new Thread() {
@Override
public void run() {
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
e.printStackTrace();
}
// a. 定义要发送的消息
Message msg = Message.obtain();
msg.what = 2;// 消息标识