前言
handler是Android中独特的线程间通信方式.我们使用handler的经典模式是,在主线程中创建一个handler并重写其handlerMessage方法,然后在子线程中发送消息让handler进行处理.下面,就来看看这个handler里面到底是怎么实现的.
@TODO:handler经典用法
创建Handler
//Handler的构造函数
public Handler(Callback callback, boolean async) {
.....代码省略...
mLooper = Looper.myLooper(); //取出looper对象
if (mLooper == null) { //判断looper是否为空
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");//
}
mQueue = mLooper.mQueue; //取出looper的MessageQueue对象
mCallback = callback;
mAsynchronous = async;
}
其中,myLooper()方法,最终调用了sThreadLocal.get()方法,从sThreadLocal中取出Looper.
sThreadLocal是一个ThreadLocal对象,它可以保证每个线程中只有一个Looper对象.关于ThreadLocal具体可以参考这篇文章.
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
接下来,判断mLooper对象是否为空,为空则抛出异常:"如果没有调用Looper.prepare()方法,则不能创建Handler"
为什么呢?我们一般在主线程创建handler的时候,并没有调用过prepare方法,
//Looper类
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
private static void prepare(boolean quitAllowed) {
.....代码省略....
sThreadLocal.set(new Looper(quitAllowed));
}
//ActivityyThread 类
public static final void main(String[] args) {
SamplingProfilerIntegration.start();
……
Looper.prepareMainLooper();
}
那为什么没有抛出这个异常呢?
我们看到ActivityThread中,已经调用了looper.prepareMainLooper()方法创建一个looper对象并放到容器sThreadLocal中.
另外,在创建looper的同时创建了一个消息队列.
创建消息
一般通过message.obtain(),从message pool中,取出复用的空消息,并给msg设置相应的数据obj,标识what,when等属性.
message主要是对我们发送的消息进行此一次封装.
handler发送消息到消息队列
创建完消息后,我们会调用handler.sendMessage()方法,将消息发送到消息队列,而sendmessage方法最终调用enqueueMessage方法,
首先调用msg.target = this;把当前的handler对象赋值给msg的target,这里就实现了handler与msg的绑定,后续在消息分发给handler处理的时候,就知道该由哪个handler来处理了.
至于enqueueMessage方法,主要是将消息列表里面的第一条消息取出,进行时间的对比排序.
public final boolean sendMessageAtFrontOfQueue(Message msg) {
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, 0);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
Looper轮询器
刚才在ActivityThread中,在Looper.prepareMainLooper()方法之后,还调用了Looper.loop()方法
为什么突然讲到这个呢?我们将消息放到请求队列之后,需要调用looper的loop方法,不断从消息队列中取出消息,并分发给对应的handler来执行.
public static void loop() {
final Looper me = myLooper();
......
final MessageQueue queue = me.mQueue;
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
return;
}
Printer logging = me.mLogging;
msg.target.dispatchMessage(msg);//分发消息给对应的handler
}
//Handler类:
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg); //这里就是我们重写的handleMessage方法
}
}
Loop()方法中的主要逻辑是不断从消息队列中取出消息,并将消息分发给对应的handler.
然后会调用handler的dispatchMessage方法,处理消息.至此,全过程过程完成.
注意了,当我们在子线程中创建handler时,除了需要手动调用Looper.prepare()方法之外,还需要调用Looper.loop()方法开启轮询.
异步消息处理机制
Handler进行消息处理的模式,总体来说如下:
1.Handler发送消息到消息队列MessageQueue,并创建Looper开启轮询,
2.Looper对象不停遍历MessageQueue,从消息队列中取出消息.分发给对应的handler
3.handler获得消息后,调用handleMessage方法处理消息.
扩展: HandlerThread
@HydraTeam 出品 转载请注明出处