Handler原理
Handler 原理
一、Handler消息发送机制
1. 发送消息
1.1 添加消息
调用Handler.sendMessageXX方法发送消息，这些方法最终都会调到MessageQueue的enqueueMessage方法中，MessageQueue使用一个优先队列来保存添加的Message对象，执行时间越早的Message放的越靠近队头。
//加入新的头结点
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 {
// Inserted within the middle of the queue. Usually we don't have to wake
// up the event queue unless there is a barrier at the head of the queue
// and the message is the earliest asynchronous message in the queue.
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
//遍历链表，把最快执行的msg放到表头
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
//插入新的Message节点
msg.next = p; // invariant: p == prev.next
prev.next = msg;
}
这样就把一个Message加入到了MessageQueue中。下面要看的就是怎么样取出消息。
1.2 取出消息
在Looper.loop()方法中通过一个死循环来不断的从MessageQueue中取出Message
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
//使本线程休眠
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
// Try to retrieve the next message. Return if found.
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
// Stalled by a barrier. Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());//默认不是异步的
}
if (msg != null) {
if (now < msg.when) {
// Next message is not ready. Set a timeout to wake up when it is ready.
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// Got a message.
mBlocked = false;
if (prevMsg != null) {
//不是队头
prevMsg.next = msg.next;
} else {
//队头
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
return msg;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}
在MessageQueue方法中也有一个for循环来从优先队列中找出一个符合条件的Message。
-
由于
MessageQueue中保存的Message是按有限顺序排列的所以第一个一定是最先执行的，先取出第一个，然后判断这个Message是否可以开始处理，if (now < msg.when) { // Next message is not ready. Set a timeout to wake up when it is ready. nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE); }如果不可以，计算还差多少时间可以处理这个
Message，并把计算的时间赋值给nextPollTimeoutMillis,这样当循环到下一次的时候就会调用nativePollOnce这个方法来使本线程休眠，当休眠时间到了之后就重新取出一个Message然后返回，这样，MessageQueue.next方法就执行结束，loop方法就能拿到一个新的Message. -
Loop方法拿到Message之后判断是否为空，如果是那loop方法死循环就结束，相当于Looper就停止工作。如果不为空就调用
Message.target.dispatchMessage方法。在loop方法拿Message的过程中可能会因为MessageQueue的休眠而导致卡主 -
Message.target是一个Hander的引用，msg.target = this;在Handler的enqueueMessage中会将当前Handler设置为Message.target的引用。所以这个方法最终也就是调用Handler.dispatchMessage方法，public void dispatchMessage(@NonNull Message msg) { if (msg.callback != null) { handleCallback(msg); } else { if (mCallback != null) { if (mCallback.handleMessage(msg)) { return; } } handleMessage(msg); } }这个方法最终会调到
handleMessage方法中，也就是在创建Handler实例时重写的那个方法。这样就能处理到这个Message。
[图片上传失败...(image-1acb02-1593160818812)]
二、Looper与线程的数量关系
结论：每条线程只有一个Looper
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
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中维护了一个ThreadLoacal的静态变量，当调用这个Looper的prepare方法时会先判断当前的线程是否有一个Looper的实例，如果没有就创建一个。
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维护了一个类似于HashMap的数据结构用线程号作为Key，这样就保证了每条线程只会有一个对应的实例。
所以，Looper是通过ThreadLocal来保证每条线程只有一个Looper实例。如果在同一个线程中多次调用prepare方法就会抛出异常。
三、Handler内存泄露
在实例化Handler时使用匿名内部类来重写handleMessage方法，这个Handler实例就持有了外部类的引用(通常会是一个Activity)，在sendMessage时又会使Message引用当前Handler实例,这样Message就会最终引用到Activity实例。由于Handler发送的消息存在延时机制导致线程可能休眠，这样休眠线程中的Message就会一直持有Activity的引用。并且在prepare时ThreadLocal会持有创建的Looper实例的引用，而静态的ThreadLocal又会被Looper.class持有引用。Looper.class是一个GCRoot所以在可达性分析时就不会释放Activity。
[图片上传失败...(image-170ef4-1593160818812)]
四、Handler的使用
1. 主线程上Handler的使用
在Looper源码中可以看到需用调用loop方法才能才能从MessageQueue中的取出消息并处理，但是在Activity中使用Handler时，我们并不需要去手动的prepare来调用loop方法。因为在Activity在启动的时候已经由Android自动prepare了MainLooper。
在ActivityThread.main()中已经调用了Looper.prepareMainLooper方法，这个main方法时整个应用启动的入口方法,所以在这个时候就会init主线程中的Looper。
2. 在子线程使用Looper
-
prepare()先调用prepare方法来在本线程创建一个Looper实例， -
loop(),调用loop方法来从MessageQueue中取出数据 -
quit()/quitSafty()清空MessageQueue退出``Looper
五、多个线程往MessageQueue中发消息如何保证线程安全
使用synchronized关键字对enqueueMessage和next加上当前MessageQueue的锁，这样在多个线程中操作这个MessageQueue时就能保证每次只有一个线程能执行。所以发送Message的delay时间由于等待锁的原因不一定是精确的。
六、如何创建一个Message
通过Message.obtain()方法来获取一个对象。Message中维护了一个Message对象的实例链表，当调用obtain方法时就从链表中取出一个Message实例，并将这个Message的标志位重置。然后返回这个Message实例。当使用完一个Message之后会调用recycleUnCheck()方法来重置这个Message,并将其加入到链表中。这里使用到了享元设计模式。
void recycleUnchecked() {
// Mark the message as in use while it remains in the recycled object pool.
// Clear out all other details.
flags = FLAG_IN_USE;
what = 0;
arg1 = 0;
arg2 = 0;
obj = null;
replyTo = null;
sendingUid = UID_NONE;
workSourceUid = UID_NONE;
when = 0;
target = null;
callback = null;
data = null;
//最大保存50个
synchronized (sPoolSync) {
if (sPoolSize < 50) {
next = sPool;
sPool = this;
sPoolSize++;
}
}
}
七 、quit和quitSafty的区别
1. quit
这个方法直接移除MessageQueue中所有的Message并将其重置。
private void removeAllMessagesLocked() {
Message p = mMessages;
while (p != null) {
Message n = p.next;
p.recycleUnchecked();
p = n;
}
mMessages = null;
}
2. quitSafty
这个不会移除当前已经到达执行时间的Message，会让让其正常处理完成，只会移除没有到达处理时间的Message。
private void removeAllFutureMessagesLocked() {
final long now = SystemClock.uptimeMillis();
Message p = mMessages;
if (p != null) {
if (p.when > now) {
//所有的消息都还不执行，直接将其移除
removeAllMessagesLocked();
} else {
Message n;
for (;;) {
n = p.next;
if (n == null) {
return;
}
if (n.when > now) {
//n节点及之后的节点都还不到执行的时间
break;
}
p = n;
}
p.next = null;
//将还不到执行时间的message全部移除
do {
p = n;
n = p.next;
//把target置为null
p.recycleUnchecked();
} while (n != null);
}
}
}
在执行着两个方法之后会调用nativeWake(mPtr)来唤醒在休眠的next方法，这个方法如果返回一个空的message，Looper就会推出循环。
[图片上传失败...(image-3daee6-1593160818812)]
