以前对Handler的源码有过详细阅读,但最近回想起来觉得有点模糊,所以决定写下来。
源码解读分为两个部分:1,创建消息并发送消息至消息队列,2.循环从消息队列中取出消息并执行。
首先是第一部分
贴一个Handler的基本使用来做对照
创建一个handler
Handler handler=new Handler(){
@Override
public void handleMessage(Message msg) {
//do
}
};
发送消息:
Message message=Message.obtain();
message.what=0;
handler.sendMessage(message);
简单的使用方式
先做准备工作,看看Message的结构:
public int what;
public int arg1;
public int arg2;
Message next;//指向下一个message对象
Handler target;//目标handler
public static final Object sPoolSync = new Object();
private static Message sPool;//当前message对象
可以看到一个message除了自身之外,还维护了下一个message的引用
然后是Handler的结构:
//主要是两个
final Looper mLooper;//looper
final MessageQueue mQueue;//消息队列
先来看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();
}
如果当前message不为null则返回当前message,否则新建一个message
再看看Hndler的创建:
public Handler(Callback callback, boolean async) {
if (FIND_POTENTIAL_LEAKS) {
final Class<? extends Handler> klass = getClass();
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
(klass.getModifiers() & Modifier.STATIC) == 0) {
}
}
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
看看mLooper = Looper.myLooper();做了什么:
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
这里出现了一个ThreadLocal,这是什么东西呢,简单描述下:
ThreadLocal的作用是为线程存储变量,在这里就是把looper作为值存进去.
然后找到该线程所对应的ThreadLocalMap,再把Thread作为key,与value一起存储进ThreadLocalMap中
ThreadLocalMap维护了一个单项链表数组:Entry[] table
Thread和value就是被存进了这里面
接着发送消息handler.sendMessage(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);
}
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");
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);
}
消息队列的enqueueMessage:
boolean enqueueMessage(Message msg, long when) {
synchronized (this) {
if (mQuitting) {
IllegalStateException e = new IllegalStateException(
msg.target + " sending message to a Handler on a dead thread");
Log.w(TAG, e.getMessage(), e);
msg.recycle();
return false;
}
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
// New head, wake up the event queue if blocked.
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
msg.next = p; // invariant: p == prev.next
prev.next = msg;
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
将消息执行的时间写入Message
这个方法的任务就是将创建的msg置于消息队列的最后,也就是 prev.next = msg;
到这里,就完成了创建消息与将消息传入消息队列。
第二部分:取出消息并执行。
谁负责把消息取出来呢
似乎有一个类忘记了介绍:Looper
先来看看Looper的创建方法:
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
Lopper在创建的时候,新建了一个消息队列,并且获取当前线程引用
注意,Looper存储的是当前的运行的线程,举个例子:
new Thread(()-> new Handler().post(()-> System.out.println("Thread:"+Thread.currentThread().getName())));
比如在如上代码中,Looper存储的是new Thread,所以是不能在Handler里面进行ui操作的
接着是Looper.prepare():
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));
}
ThreadLocal的set方法内容:
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
可以看到,ThreadLocal获取当前线程,然后把value存储进ThreadLocalMap当中,这个在上文有提到过。
最后是Looper.loop();
public static void loop() {
final Looper me = myLooper();
final MessageQueue queue = me.mQueue;
//确保当前线程是属于本地进程的
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
boolean slowDeliveryDetected = false;
...//已省略部分代码
for (;;) {//重要部分
Message msg = queue.next(); // might block
if (msg == null) {//如果没有消息 退出循环
return;
}
final long traceTag = me.mTraceTag;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
try {
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
msg.recycleUnchecked();
}
}
loop无限循环取出消息队列里面的Message
在拿到Message所发送的target(Handler),调用Handler的dispatchMessage():
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
最后就是回调回Handler的handleMessage;
至此Handler的整个工作机制就完成了