文章目录
一、Handle机制
1、简介
Handler机制是一套Android消息传递机制。在Android开发多线程的应用场景中，将工作线程中需更新UI的操作信息 传递到 UI主线程，从而实现 工作线程对UI的更新处理，最终实现异步消息的处理。
2、重要成员
1、主线程（UI线程、MainThread）
当应用程序第一次启动时，会同时自动开启1条主线程，用于处理UI相关的事件（如更新、操作等）
2、子线程（工作线程）
人为手动开启的线程，执行耗时操作（如网络请求、数据加载等）
3、消息（Message）
线程间通讯的数据单元（即Handler接受 & 处理的消息对象），用于存储需要操作的通信信息
4、消息队列（Message Queue）
一种数据结构（先进先出），存储Handler发送过来的消息（Message）
5、处理者（Handler）
Handler为主线程与子线程的通信媒介，是线程消息的主要处理者。用于添加消息（Message）到消息队列（Message Queue），处理循环器（Looper）分派过来的消息（Message）
6、循环器（Looper）
消息队列（Message Queue）与处理者（Handler）的通信媒介，用于消息循环，即
（1）消息获取：循环取出消息队列（Message Queue）的消息（Message）
（2）消息分发：将取出的消息（Message）发送给对应的处理者（Handler）
每个线程只能拥有1个Looper，1个Looper可绑定多个线程的Handler，即多个线程可往1个Looper所持有的MessageQueue中发送消息，提供线程间通信的可能
3、使用方式
3.1、Handler.sendMessage()
方式1：新建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：匿名内部类
/**
* 方式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();
}
3.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.3、Handler.sendMessage与Handler.post比较
工作流程类似，区别在于
1、Handler.post不需外部创建消息对象，而是内部根据传入的Runnable对象封装消息对象
2、回调的消息处理方法是：复写Runnable对象的run()
4、工作流程原理
-
（1）首先，任务的开始是由创建一个Message开始的，Message创建完毕后交给Handler对象发送，sendMessage和sendMessageDelay最终都是在底层调用了sendMessageAtTime()方法，将Message对象放入MessageQueue中的。
-
（2）之后，由Looper的loop()方法循环从MessageQueue中取出Message对象，调用message.getTarget ()获取到发送消息的Handler对象，然后再调用handler.dispatchMessage()方法将信息分发给对应handler执行。
-
（3）最后，Handler在dispatchMessage()方法中判断是否有callback 存在，存在则执行callback的onMessageHandler()，最终交由Message.callback执行；否则则执行handler的onMessageHandler()方法。
5、源码解析
6、使用泄露问题
6.1 泄露原因
在Handler消息队列 还有未处理的消息 / 正在处理消息时，消息队列中的Message持有Handler实例的引用
由于Handler = 非静态内部类 / 匿名内部类（2种使用方式），故又默认持有外部类的引用（即MainActivity实例）
此时若需销毁外部类MainActivity，但由于上述引用关系，垃圾回收器（GC）无法回收MainActivity，从而造成内存泄漏
6.2 解决办法
方式一：静态内部类+弱引用（推荐：保证消息队列中所有消息都能执行）
（1）原理
1、将Handler的子类设置成 静态内部类：默认不持有外部类的引用，从而使得 “未被处理 / 正处理的消息 -> Handler实例 -> 外部类” 的引用关系 的引用关系 不复存在。
2、使用WeakReference弱引用持有Activity实例：弱引用的对象拥有短暂的生命周期。在垃圾回收器线程扫描时，一旦发现了只具有弱引用的对象，不管当前内存空间足够与否，都会回收它的内存
（2）代码
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();
}
// 分析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;
}
}
}
}
方案2：当外部类结束生命周期时，清空Handler内消息队列
1）原理
当 外部类（此处以Activity为例） 结束生命周期时（此时系统会调用onDestroy（）），清除 Handler消息队列里的所有消息（调用removeCallbacksAndMessages(null)）
不仅使得 “未被处理 / 正处理的消息 -> Handler实例 -> 外部类” 的引用关系 不复存在，同时 使得 Handler的生命周期（即 消息存在的时期） 与 外部类的生命周期 同步
弊端：发送的消息未能处理
面试总结
1、Handle机制流程详解
2、一个线程几个 Looper，几个 Handler，Looper 如何确定是哪个 Handler？
一个线程只有一个Looper来处理MessageQueue中的消息；Handler可以有多个，用来发送及处理消息。Looper不需要确定是那个Handler发送过来的消息，因为Message有个targ字段封装了发送他的handler,系统直接通过message.getTarg().hanldMessage();就可以调用到handler的处理消息方法。
3、两个均不是主线的线程如何用Handler通信
需要在处理逻辑的线程Thread1创建Looper，有了Looper之后才能创建Handler；
之后在需要发消息的线程Thread2使用Thread1的handler对象发送Message；
public class MainActivity extends ComponentActivity {
private static final String TAG = "MainActivity";
private Looper looper2;
private Thread1 thread1;
private Thread thread2;
private Handler child1Handler, child2Handler;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
initView();
}
private void initView() {
setContentView(R.layout.activity_main);
thread1 = new Thread1("ChildThread1");
thread2 = new Thread2("ChildThread2");
thread1.start();
thread2.start();
}
private void initHandler() {
child1Handler = new Handler(thread1.getLooper()) {
@Override
public void handleMessage(@NonNull Message msg) {
String ms = (String) msg.obj;
Log.e(TAG, "当前线程：" + Thread.currentThread().getName() + " 消息：" + ms);
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Message message = Message.obtain();
message.obj = "你好,我是" + Thread.currentThread().getName() + "!";
child2Handler.sendMessage(message);
}
};
child2Handler = new Handler(looper2) {
@Override
public void handleMessage(@NonNull Message msg) {
String ms = (String) msg.obj;
Log.w(TAG, "当前线程：" + Thread.currentThread().getName() + " 消息：" + ms);
try {
Thread.sleep(1500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Message message = Message.obtain();
message.obj = "你好,我是" + Thread.currentThread().getName() + "!";
child1Handler.sendMessage(message);
}
};
}
class Thread1 extends HandlerThread {
public Thread1(String name) {
super(name);
}
}
class Thread2 extends Thread {
public Thread2(String name) {
super(name);
}
@Override
public void run() {
Looper.prepare();
looper2 = Looper.myLooper();
initHandler();
Message message = Message.obtain();
message.obj = "你好,我是" + Thread.currentThread().getName() + "!";
child2Handler.sendMessage(message);
Looper.loop();
}
}
}
4、在任何地方new Handler 都是什么线程下
1）对于不传递 Looper 对象的情况下，在哪个线程创建 Handler 默认获取的就是该线程的 Looper 对象，那么 Handler 的一系列操作都是在该线程进行的
2）对于传递 Looper 对象创建 Handler 的情况下，传递的 Looper 是哪个线程的，Handler 绑定的就是该线程
5、可以再子线程new一个Handle吗
主线程获得Looper方法是：Looper.getMainprepare()
可以在子线程直接new一个Handler，不过需要在一个线程里需要先调用Looper.prepare()和Looper.loop()方法
6、Handler.sendMessage与Handler.post比较
文中有答案
7、11）Message可以如何创建？哪种效果更好，为什么？
- Message msg = new Message();
- Message msg = Message.obtain();
- Message msg = handler1.obtainMessage();
后两种方法都是从整个Messge池中返回一个新的Message实例，能有效避免重复Message创建对象，因此更鼓励这种方式创建Message
8、Handler中有Loop死循环，为什么没有阻塞主线程，原理是什么
在主线程的MessageQueue没有消息时，便阻塞在loop的queue.next()中的nativePollOnce()方法里，此时主线程会释放CPU资源进入休眠状态，直到下个消息到达或者有事务发生，通过往pipe管道写端写入数据来唤醒主线程工作。这里采用的epoll机制，是一种IO多路复用机制，可以同时监控多个描述符，当某个描述符就绪(读或写就绪)，则立刻通知相应程序进行读或写操作，本质同步I/O，即读写是阻塞的。 所以说，主线程大多数时候都是处于休眠状态，并不会消耗大量CPU资源
9、Handler 是如何能够线程切换，发送Message的
Handler创建的时候会采用当前线程的Looper来构造消息循环系统，Looper在哪个线程创建，就跟哪个线程绑定，并且Handler是在他关联的Looper对应的线程中处理消息的
10、为什么不能在子线程更新UI?子线程一定不能更新UI？
Android的UI控件不是线程安全的，如果在多线程中并发访问可能会导致UI控件处于不可预期的状态
子线程可以在ViewRootImpl还没有被创建之前更新UI；
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
