前言
提到Handler相信大家都不陌生, 经常被我们应用于切换线程更新UI. 面试官也经常会问到Handler异步消息处理机制中Handler, Looper, Message三者之间的关系, 今天就从源码的角度分析一下.
概述
看一下Handler源码中的注释:
每一个Handler实例都和一个唯一的线程及线程的消息队列MessageQueue相关联, 主要用来发送处理Message或Runnable.
当你创建Handler时, 这个handler实例就和当前线程以及线程创建的消息队列绑定了, 然后就可以向消息队列中发送Message或Runnable, 执行Message或Runnable时从消息队中移除.
主要用途:
- 在未来某一时刻执行Message和Runnable;
- 在不同的线程执行操作;
用法
上面说了Handler的两个主要用途, 延时执行和切换线程;
延时执行很简单:
Runnable可以通过postAtTime, postDelayed方法实现;
Message可以通过sendMessageAtTime, sendMessageDelayed方法实现.
切换线程需要注意几点:
- 创建Handler实例时可以指定Looper, 不指定时默认为当前线程的Looper;
- 在子线程中更新UI时, 创建Handler, 必须指定Looper为主线程的Looper, 如果不指定则必须调用Looper.prepare()和Looper.loop(), 否则会报错;
写个简单的demo:
new Thread(){
@Override
public void run() {
super.run();
//指定Looper为主线程的Looper
Handler handler1 = new Handler(Looper.getMainLooper());
handler1.post(new Runnable() {
@Override
public void run() {
//在主线程执行
Log.d("fragment", "run1: "+Thread.currentThread().getName());
tvText.setText("update UI");
}
});
}
}.start();
new Thread(){
@Override
public void run() {
super.run();
//不指定Looper, 则必须调用Looper.prepare()
Looper.prepare();
Handler handler1 = new Handler();
handler1.post(new Runnable() {
@Override
public void run() {
//在子线程执行
Log.d("fragment", "run2: "+Thread.currentThread().getName());
tvText.setText("update UI");
}
});
Looper.loop();
}
}.start();
运行结果:
fragment: run2: Thread-156
fragment: run1: main
从demo中可以看出, Looper可以改变Handler执行任务的线程, 看来Looper在Handler消息处理中的作用举足轻重, 首先看下Looper的源码;
Looper
Looper为线程开启一个消息循环体, 线程默认没有相关联的消息循环体, 必须在线程中调用prepare()来开启消息循环体, 然后调用loop()处理消息, 直到循环结束;
- 构造方法和ThreadLocal属性
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
ThreadLocal, 上篇文章已经分析过了, 主要是为每个线程独立维护一个变量, 使不同线程之间不受影响, 因此每一个线程都有一个独立的Looper. 而每一个Looper内部都维护了一个消息队列MessageQueue.
- prepare()方法
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
//主线程中调用该方法设置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();
}
}
如果sThreadLocal已经有值, 就抛异常, 否则重新创建一个Looper对象, 放入sThreadLocal中, 这就保证了一个线程只有一个Looper对象. 因此prepare()方法主要是保证当前线程有且只有一个Looper对象.
- loop()方法
public static void loop() {
//获取当前线程的Looper对象
final Looper me = myLooper();
//Looper对象为空则抛异常, 所以之前必须调用prepare设置Looper对象
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
//获取Looper中维护的消息队列
final MessageQueue queue = me.mQueue;
Binder.clearCallingIdentity();
//处理消息前记录当前线程的id
final long ident = Binder.clearCallingIdentity();
//进入无限循环, 遍历消息队列中的消息
for (;;) {
//从消息队列中取出一条消息(阻塞式)
Message msg = queue.next(); // might block
//没有消息则退出循环
if (msg == null) {
return;
}
// 打印消息相关内容
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long traceTag = me.mTraceTag;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
//通过消息的target处理消息
try {
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
// 消息处理完, 重新计算当前线程的id, 不一致则打印相关信息
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}
//释放消息
msg.recycleUnchecked();
}
}
//获取当前线程的Looper对象
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
loop()方法, 首先取出当前线程中的Looper对象及消息队列, 然后不断从消息队列中取出消息, 调用target属性的dispatchMessage方法处理消息.
综上, Looper的主要作用就是保证每个线程都有一个独立的Looper对象和消息队列, 通过循环从消息队列中取出消息交给target处理. 那么target是谁呢, 其实就是Handler, 下面来看下handler.
Handler
- 构造方法
public Handler() {
this(null, false);
}
public Handler(Callback callback) {
this(callback, false);
}
public Handler(Looper looper) {
this(looper, null, false);
}
public Handler(Looper looper, Callback callback) {
this(looper, callback, false);
}
public Handler(boolean async) {
this(null, async);
}
public Handler(Callback callback, boolean async) {
//默认false
if (FIND_POTENTIAL_LEAKS) {
final Class<? extends Handler> klass = getClass();
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
(klass.getModifiers() & Modifier.STATIC) == 0) {
Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
klass.getCanonicalName());
}
}
//获取创建Handler线程的Looper对象
mLooper = Looper.myLooper();
//Lopper对象为空抛异常
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
//获取Looper维护的消息队列
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
创建Handler对象时首先获取当前线程的Looper对象, 为空则抛异常, 因此创建Handler对象之前, 必须调用Looper.prepare()方法设置当前线程的Looper对象, 如demo所示.
但是为什么在主线程中创建Handler对象就不需要调用Looper.prepare()和Looper.loop()呢?
看下主线程即ActivityThread的入口main方法
public static void main(String[] args) {
......
Process.setArgV0("<pre-initialized>");
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
可以看到main方法中通过Looper.prepareMainLooper()为主线程设置Looper对象. 然后调用Looper.loop()开启了消息循环.
- 发送Runnable的方法
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
public final boolean postAtTime(Runnable r, long uptimeMillis)
{
return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}
public final boolean postDelayed(Runnable r, long delayMillis)
{
return sendMessageDelayed(getPostMessage(r), delayMillis);
}
private static Message getPostMessage(Runnable r) {
//从线程池中获取一个消息
Message m = Message.obtain();
//把Runnable赋值给Message的callback属性
m.callback = r;
return m;
}
可以看出, 发送的Runnable被转换成Message保存在callback属性中.
- 发送Message的方法
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}
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) {
//获取当前线程中Looper对象维护的消息队列
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) {
//把当前Handler对象赋值给要处理message的target属性
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
//把当前消息及执行时间放进消息队列中
return queue.enqueueMessage(msg, uptimeMillis);
}
发送消息时把当前handler对象赋值给了要处理的Message的target属性, 然后保存到消息队列中.
还记得上面Looper.loop()方法中, 从消息队列中取出消息并处理是调用了msg.target.dispatchMessage(msg), 而msg.target就是当前Handler对象, 一起看下Handler的dispatchMessage方法:
- 处理消息dispatchMessage
public void dispatchMessage(Message msg) {
//首先处理msg的callback, 及Runnable
if (msg.callback != null) {
handleCallback(msg);
} else {//调用handler构造方法中传入的Callback接口
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
private static void handleCallback(Message message) {
message.callback.run();//及Runnable的run方法
}
public interface Callback {
public boolean handleMessage(Message msg);
}
public void handleMessage(Message msg) {
}
handler处理消息时, 先处理发送message的callback, 或者发送Runnable中的run方法, 如果message无callback, 则处理handler对象创建时传入的Callback接口的具体实现handleMessage, 如果该方法返回true, 消息处理结束, 如果返回false, 处理完该接口实现, 还需处理handler对象复写的handleMessage方法;
消息处理的优先级: message.callback>mCallback接口实现方法>复写的handleMessage方法.
小结
Handler的使用流程
- Looper.preapare(): 为当前线程创建一个Looper实例及消息队列;
- new Handler(mCallback): 实现接口mCallBack或复写Handler的handlerMessage方法;
- handler.post或sendMessage: 通过handler对象向当前线程的消息队列中发送消息;
- Looper.loop(): 不断从消息队列中取出消息, 并交给发送该消息的handler对象进行处理, 消息处理优先级: handler.post进来的Runnable或者sendMessage进来的Message的callback>Handler构造方法中的传入的Callback>创建Handler对象时复写的handleMessage方法.
Handler, Looper, MessageQueue三者之间的关系
handler用于向消息队列中发送消息, 以及消息的具体处理.
Looper为当前线程创建唯一的Looper对象和消息队列, 然后不断从消息队列中取出消息并交给发送消息的handler对象处理消息.
MessageQueue消息队列, 用来存放Handler发送的消息.
注意: 如果同一个线程中有多个Handler对象发送消息, 消息会发送到同一个消息队列中, 但是处理时会交给发送消息的那个handler对象进行处理.
Handler切换线程的原理
通过Looper.prepare()为当前线程创建一个Looper, 而Looper内部又维护了一个MessageQueue, 相当于每个线程都只有一个Looper和MessageQueue.
创建Handler对象时指定Looper, 就相当于指定了MessageQueue, 然后通过Handler发送消息时就是向对应线程的MessageQueue中发送消息.
通过Looper.loop()从MessageQueue中取出消息并交给对应的Handler对象处理, 该处理过程是在Looper对应线程中执行的.
因此, 为Handler指定Looper就相当于为Handler消息处理指定了切换的线程.
handler.png
网友评论