文章目录
- 一、Handle机制
- 1、简介
- 2、重要成员
- 3、使用方式
- 3.1、Handler.sendMessage()
- 3.2、Handler.post()
- 3.3、Handler.sendMessage与Handler.post比较
- 4、工作流程原理![在这里插入图片描述](https://img-blog.csdnimg.cn/bb20a4cdea0341efa0409a951f3f92f9.png?x-oss-process=image/watermark,type_ZHJvaWRzYW5zZmFsbGJhY2s,shadow_50,text_Q1NETiBA5aSpLeepui3ok50=,size_20,color_FFFFFF,t_30,g_se,x_16)
- 5、源码解析
- 6、使用泄露问题
- 6.1 泄露原因
- 6.2 解决办法
- 方式一:静态内部类+弱引用(推荐:保证消息队列中所有消息都能执行)
- 方案2:当外部类结束生命周期时,清空Handler内消息队列
- 面试总结
- 1、Handle机制流程详解
- 2、一个线程几个 Looper,几个 Handler,Looper 如何确定是哪个 Handler?
- 3、两个均不是主线的线程如何用Handler通信
- 4、在任何地方new Handler 都是什么线程下
- 5、可以再子线程new一个Handle吗
- 6、Handler.sendMessage与Handler.post比较
- 7、11)Message可以如何创建?哪种效果更好,为什么?
- 8、Handler中有Loop死循环,为什么没有阻塞主线程,原理是什么
- 9、Handler 是如何能够线程切换,发送Message的
- 10、为什么不能在子线程更新UI?子线程一定不能更新UI?
一、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;