Hanlder的作用
相信做Andorid开发的工程师对Handler的使用都不陌生,那为什么还会有这篇文章呢,只是为了加强自己的记忆,好了言归正传,话说为什么Android要引入Handler呢?我想最本质的目的是为了实现跨线程通信的,那为什么要设计成只能通过Handler机制来更新UI呢?我想最本质的目的就是解决多线程并发的问题。就比如如果没有这套机制,有多个线程去同时更新UI,会出现什么问题,会是界面很混乱,无法控制更新UI的先后顺序,但这时会有人说,那就加锁呗,可加锁势必会影响响应速度,给用户的体验势必会下降。所以Handler机制就应运而生了。Handler机制就是不断的从消息队列中取消息,然后再发送到UI线程进行UI的更新。既然是消息队列,那肯定也就保证了消息的先进先出顺序执行了。
这篇文章的重点是Handler的使用,当然也会简单的分析一下源码, 至于Hanlder的工作原理请关注另一篇文章。
Hanlder的使用
首先在Activity中先创建一个Handler对象如下:
private static Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
Object object = msg.obj;
Bundle bundle = msg.getData();
int anInt = bundle.getInt("handler", 0);
Log.d("HandlerActivity:", "arg1:" + msg.arg1 + " arg2:" + msg.arg2 + " object:" + object.toString() + " bundleInt:" + anInt);
break;
case 2:
Log.d("HandlerActivity:", "Message.obtain()");
break;
case 3:
Log.d("HandlerActivity:", "handler.obtainMessage();");
break;
default:
Log.d("liuy=default=", "handler");
break;
}
}
};
细心的同学可能已经发现了,刚刚创建Handler的代码有一个警告,鼠标放上给出的提示是:This Handler class should be static or leaks might occur (null) more,大致意思是Handler类应该定义成静态类,否则可能导致内存泄露。所以有强迫症的同学要想去除这些警告,那就需要把Handler定义成静态类并加上WeakRefrence的机制,基本上可以避免出现泄漏的情况。但这种写法太繁琐了,所以就有了另一种写法,如下:
private static Handler handler2 = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
Log.d("HandlerActivity:", "handle---");
return true;
}
});
这种写法只是创建了一个静态对象,并不是匿名内部类,所以也就不会持有外部类的引用,就不会出现警告了。可这里又有一个返回值,那返回值的作用是什么呢?这就需要看下源码:
首先创建一个有参构造的Handler对象和Callback对象
public Handler(Callback callback) {
this(callback, false);
}
public interface Callback {
public boolean handleMessage(Message msg);
}
再跟进入是:
public Handler(Callback callback, boolean async) {
....省略....
mCallback = callback;
....省略....
}
这里我们只需知道把我们在外面创建的Callback对象赋值给了Handler的全局变量mCallback了。
当有消息需要处理时,会回调Hanlder的dispatchMessage()方法:
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
if (msg.callback != null)这条语句等到下一遍源码分析再讲解,先专注else里的代码,首先判断了下mCallback是否为空,既然我们在上边已经给他赋值了,那肯定不为空,那就会调用Callback的handleMessage方法,并把消息也传递过去,当消息处理完以后,如果返回false,那就会继续往下执行,执行第10行的handleMessage(msg)方法,当然这时又会出现内存泄漏的警告提示,所以一般我们都返回true就可以了。
Message的使用
Message对象获取有很多种,下面就一一介绍:
第一种:
private void sendMsg0() {
Message msg = new Message();
msg.what = 1;
msg.arg1 = 1;
msg.arg2 = 2;
msg.obj = new Object();
msg.obj = new People("小明");
Bundle bundle = new Bundle();
bundle.putInt("handler", 1);
msg.setData(bundle);
handler.sendMessage(msg);
}
msg.what是消息的识别码,便于在Handler的handleMessage方法中根据what识别出不同的消息
msg.arg1,msg.arg2是Message给我们提供的两个int类型的传递,是setData的低成本替代品
msg.obj可以传递一个对象
msg.setData()可以传递一个Bundle对象
Message对象可以直接new一个,这种方式官方是不建议的,因为可以使用消息池的对象。
第二种:
private void sendMsg2() {
Message msg = Message.obtain();
msg.what = 2;
handler.sendMessage(msg);
}
通过obtain()先从消息池中获取Message对象,如果池中没有则创建一个对象并返回,空说无凭来看下源码:
public static 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;
}
}
return new Message();
}
sPool是消息池中的一个对象
第3行先判断消息池中是否有对象,没有则直接new一个Message,有则把sPool赋值给Message并把消息池中的上一条赋值给sPool,然后再把消息池中的数量减一。
看到这肯定会有一个疑问,那什么时候赋值的呢,那就简单的介绍一下,具体介绍请看下一篇Handler的源码解析。
首先在Looper.loop()方法中对消息进行循环,消息执行完以后会放到消息池进行缓存
public static void loop() {
....省略......
for (;;) {
....省略......
msg.recycleUnchecked();//消息进行回收
}
}
void recycleUnchecked() {
....省略......
synchronized (sPoolSync) {
if (sPoolSize < MAX_POOL_SIZE) {
next = sPool;//把使用完的消息赋值给next
sPool = this;
sPoolSize++;//消息池数量+1
}
}
}
看到这里应该能明白点了吧,其实就是把不用的Message放到消息池里边
第三种:
private void sendMsg3() {
Message msg = handler.obtainMessage();
msg.what = 3;
//只有通过handler获取的的Message对象,才能使用下边这种
//方法发送消息
msg.sendToTarget();
}
这种写法其实就是把第二种写法又封装了下,可以看到里边还是调用了obtain()方法
public final Message obtainMessage()
{
return Message.obtain(this);
}
public static Message obtain(Handler h) {
Message m = obtain();
m.target = h;//把hanlder赋值给target
return m;
}
再来看一下sendToTarget()方法
public void sendToTarget() {
target.sendMessage(this);
}
是不是和hanlder发送消息差不多呢,其实就是一样的,target就是handler。
Handler的post理解与用法
先看一下用法:
private void sendMsg6() {
handler.post(new Runnable() {
@Override
public void run() {
Log.d("HandlerActivity:", "postRunnable");
}
});
}
咋一看像是开了一个子线程,其实静心一想不对,开线程调用的是start()方法啊,这里什么都没调用,所以并没有改变当前的线程。先看下源码吧
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
再看下getPostMessage()方法
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
第2行还是从消息池中获取Message
第3行把Runnable对象赋值给callback
第4行返回Message
再看下sendMessageDelayed方法
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;//获取消息队列
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
//把消息放到消息队列中
return queue.enqueueMessage(msg, uptimeMillis);
}
这里其实就是把Runnable对象封装到Message对象中并压入到消息队列,当消息队列中有消息后,就会循环消息,当消息执行完以后就会回调dispatchMessage方法
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
还记得开头说的这个if语句吗,当我们发送一个post方法时,已经给callback赋值了,所以这里走if语句,那再看下handleCallback方法
private static void handleCallback(Message message) {
message.callback.run();
}
还记得message.callback是什么吗,就是把Runnable压入到Message对象中的Runnable对象,所以这个方法就是执行了下Runnable的run方法。说的有些啰嗦,大家理解就好。
Handler其他使用
private void sendMsg4() {
Message msg = handler.obtainMessage();
handler.sendEmptyMessage(4);
//SystemClock.uptimeMillis():从开机到现在的毫秒数(手机深度睡眠的时间不包括在内)
//System.currentTimeMillis():获取的是系统的时间,可以使用SystemClock.setCurrentTimeMillis(long millis)进行设置
//如果人为设置这个时间,那发送的延迟任务就不准了
//sendMessageAtTime->enqueueMessage
handler.sendEmptyMessageAtTime(5, 2000);//2000:延迟时间
//sendMessageDelayed-> sendMessageAtTime->enqueueMessage
handler.sendEmptyMessageDelayed(6, 2000);
//enqueueMessage
handler.sendMessageAtTime(msg, 2000);
//sendMessageAtTime->enqueueMessage
handler.sendMessageDelayed(msg, 2000);
//删除消息
handler.removeMessages(1);
}
这几种发送消息的方法其实最终都是调用了enqueueMessage()方法,也没什么好说的。