什么是Handler?
android处理用来更新UI的一套机制,也是消息处理的一套机制,可以用来发送消息,也可以用来处理消息.
多个生产者,一个消费者的线程模型.
为什么要用Handler
异步耗时操作,使用handler更新UI
怎么使用
发送/移除消息
Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
//主线程的回调
}
}
//第一种
Message message = new Message();
//...arg1,arg2,what,obj相关赋值
handler.sendMessage(message);
//第二种 复用msg
Message message = handler.obtainMessage();
//...arg1,arg2,what,obj相关赋值
message.sendToTarget();
//第三种 直接发送
handler.sendEmptyMessage();
//第四种 延迟发送
handler.sendMessageDelayed();
//第五种 指定时间
handler.sendMessageAtTime();
//第六种 插入到队列前侧
handler.sendMessageAtFrontOfQueue();
//以上msg的发送方式,都会进入handler的handleMsg()方法里
//第七种 该方法将直接调用Message内部的Runnable(具体见handler的dispathMessage()下文在looper部分时有讲到)
Message.obtain(handler, new Runnable() {
@Override
public void run() {
}
}).sendToTarget();
//移除消息
handler.removeCallBacks(runnable);
处理消息
Handler handler = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
//截获msg消息 返回值true代表消息被截获,不再向下执行
return false;
}
}) {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
}
};
为什么要设计只能通过Handler来更新UI
- 更新界面错乱
多个线程更新UI,并且不加锁 - 性能下降
加锁后性能就会下降
所以通过主线程消息队列的方式来更新UI(避免多线程并发)
Handler的原理
Looper
- 内部包含了一个消息队列MessageQueue
- Looper.loop()方法,不断从MQ中取消息,有就将message交给target(也就是handler),没有就阻塞.
MessageQueue
- 消息队列,消息的容器
Handler
内部与Looper关联,在handler内部可以找到looper,找到looper就是找到了MQ,
Handler负责发送消息,Looper负责接收Handler发送的消息,并把消息回传给Handler自己.MQ就是一容器
源码相关
Looper
- ActivityThread.main()
- Looper.PrepareMainLooper();
- Looper.prepare(quitAllowed);
- if(ThreadLocal.get() == null){ThreadLocal.set(new Looper())};
- new MessageQueue();
从ActivityThread的main()方法进入
然后调用Prepare方法,
new出Lopper对象,同时在looper的构造函数里,new出MQ对象
然后将looper存入到ThreadLocal中
ThreadLocal (线程本地变量)
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
简单理解为这一个对象可以为每个线程存储不同的数据
关于ThreadLocal不错的博文
Handler与Looper的关联
Handler handler = new Handler();handler.mLooper = Looper.myLooper(); //return sThreadLocal.get()handler.mQueue = mLooper.mQueue;
在Handler构造函数中,将当前线程存储的looper,mQueue对象.给到handler
Looper.loop()
用来开启消息循环.注意 该方法之后的代码都将不会执行.
为了方便观察,移除了一些不必要代码,并将for循环,改成了while(true)
public void loop(){
while(true){
// ...
Message msg = mQueue.next();
if(msg == null){
return;
}
//这里的target就是handler自身
msg.target.dispatchMessage();
// ...
}
}
// msg.target就是handler
// 所以最终调用的handler的dispathMessage()
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
//此处对应上文handler第七种发送消息的处理
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
sendMessage(Message message)
将消息加入到MessageQueue中
-
handler.sendMessage(msg);发送消息 -
msg.target = handler;绑定target -
queue.enqueueMessage(message, uptimeMills);将消息加入MessageQueue队列
总结
App在启动的时候,将主线程的Lopper和MessageQueue创建完毕.并将looper对象存至threadLocal对象,调用looper.loop()方法, 一直循环looper对象中的messageQueue.
我们在编码时,在主线程实例一个handler对象,就会通过threadLocal对象将主线程的looper对象取出,并将looper和mq对象与handler关联.这样在handler.sendMessage(msg)后,就能通过looper遍历出的msg,取出handler,来调用dispatchMessage方法
相关使用方式总结
子线程中Handler
Handler handler;
new Thread() {
@Override
public void run() {
Looper.prepare();//将该线程的looper对象存入threadLocal
handler = new Handler() {
@Override
public void handleMessage(Message msg) {
Log.i(TAG, "handleMessage: " + Thread.currentThread());
}
};
Looper.loop();
}
}.start();
//休眠500毫秒,待子线程handler创建完成
Thread.sleep(500); //可以通过HandlerThread来处理多线程并发时,对象为空的问题
//主线程通知子线程处理消息
handler.sendEmptyMessage(0);
子线程中直接调用主线程的handler
new Thread() {
@Override
public void run() {
// do something
Message.obtain(new Handler(getMainLooper()), new Runnable() {
@Override
public void run() {
Log.i(TAG, "Message.obtain " + Thread.currentThread());
}
}).sendToTarget();
}.start();
