Handler源码分析
Handler:
Handler主要是用于异步消息的处理：当发出一个消息之后，首先进入一个消息队列，发送消息的函数即刻返回，而另外一部分在消息队列中逐一将消息取出，然后对消息进行处理。
问题：
- Handler(Callback) 跟 Handler() 这两个构造方法的区别在哪， Handler什么情况下会内存泄漏？
- 刷新UI为什么只能在主线程中执行
- 为什么创建 Message 对象推荐使用 Message.obtain()获取？
- Threadlocal用法和原理
- 为什么 Handler 能够切换线程执行？
- Looper.loop() 为什么不会造成应用卡死？
问题1
Handler handler2 = new Handler() {
@Override
public void handleMessage(@NonNull Message msg) {
super.handleMessage(msg);
}
};
但是这样会报黄色警告。大体意思就是说handler应该为静态。否则会造成内存泄漏。
MessageQueue中的消息队列会一直持有对handler的引用，而作为内部类的handler会一直持有外部类的引用，就会导致外部类不能被GC回收。当我们发延时很长的msg时就容易出现泄漏。
1.新建静态类继承Handler.
所以此处应该设置为static，然后Handler就会跟随类而不是跟随类的对象加载，也就不再持有外部类的对象引用。
2.使用Handler.Callback()
Handler handler1 = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(@NonNull Message msg) {
return false;
}
});
/**
* Callback interface you can use when instantiating a Handler to avoid
* having to implement your own subclass of Handler.
*/
public interface Callback {
/**
* @param msg A {@link android.os.Message Message} object
* @return True if no further handling is desired
*/
boolean handleMessage(@NonNull Message msg);
}
/**
* Handle system messages here.
*/
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) { //若callback不为空，代表使用post(Runnable r)发送消息
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);//创建Handler实例时复写
}
}
问题二： 刷新UI为什么只能在主线程中执行
问题三：为什么创建 Message 对象推荐使用 Message.obtain()获取？
/**
* Return a new Message instance from the global pool. Allows us to
* avoid allocating new objects in many cases.
*/
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next; //spool指向下一个缓存对象
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--；
return m;
}
}
return new Message();
}
image.png
sPool 消息缓存池，若消息池不为空，则从头节点取出，置为非使用状态。若消息池为空，则新建一个Message。
private static final int MAX_POOL_SIZE = 50;
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;
synchronized (sPoolSync) {
if (sPoolSize < MAX_POOL_SIZE) {
next = sPool;
sPool = this;
sPoolSize++;
}
}
}
image.png
在Looper.loop()方法中，当msg消息处理完毕，则会调用上面Message的回收方法，将消息的参数清空，若消息池的数量少于50，则将消息插入缓存池的头结点。
问题四：Threadlocal用法和原理
ThreadLocal.java
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
void createMap(Thread t, T firstValue) {
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
可以看到上面代码，在存储和取 是以当前线程为key，looper为value。 在Handler初始化的时候会检查是否能取到looper，否则抛出异常！
ThreadLocal的作用是不同的线程拥有该线程独立的变量，同名对象不会被受到不同线程间相互使用出现异常的情况。
即：你的程序拥有多个线程，线程中要用到相同的对象，但又不允许线程之间操作同一份对象。那么就可以使用ThreadLocal来解决。它可以在线程中使用mThreadLocal.get()和mThreadLocal.set()来使用。若未被在当前线程中调用set方法，那么get时为空。
image.png
问题五：为什么 Handler 能够切换线程执行？
image.png
Handler 发送的线程不处理消息，只有Looper.loop()将消息取出来后再进行处理，所以在Handler机制中，无论发送消息的Handler对象处于什么线程，最终的处理都是运行在 Looper.loop() 所在的线程。
问题六：Looper.loop() 为什么不会造成应用卡死？
这里我们先看张流程图：
image.png
MessageQueue.java
boolean enqueueMessage(Message msg, long when) { //when = SystemClock.uptimeMillis() + delayMillis
...
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 (; ; ) { //根据消息（Message）创建时间插入到队列中
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;
}
这里可以看到传递的msg根据当前是否有message需要返回和messge的执行时间（when）排序。
image.png
这里mMessages不为空时为当前链表的第一个Message，当有message需要执行的时候，会调用
nativeWake(mPtr)方法，（将主线程唤醒）
这里Looper.loop()方法时一直在主线程循环的执行的。
public static void loop() {
final Looper me = myLooper();
...
final MessageQueue queue = me.mQueue;
...
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
return;
}
...
msg.target.dispatchMessage(msg); //派发消息到对应的Handler
...
}
}
这里面主要是next方法。msg.target为 Handler。会将从messageQueue中取message传递出去。
下面看下 dispatchMessage方法
**Handler.class**
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
dispatchMessage方法里面针对 Handler发送Message方式做了处理。
下面重点看看下next()方法。取消息的方法。
Message next() {
...
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0; ////阻塞时间：-1是一直阻塞不超时；0是不会阻塞，立即返回；大于0则nextPollTimeoutMillis是最长阻塞时间，期间有线程唤醒立即返回
for (; ; ) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
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) { //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;// 清除next
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
return msg;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1; // 若 消息队列中已无消息，则将nextPollTimeoutMillis参数设为-1 下次循环时，消息队列则处于等待状态
}
...
}
}
nextPollTimeoutMillis：
-1是一直阻塞不超时；
0是不会阻塞，立即返回；
大于0则nextPollTimeoutMillis是最长阻塞时间，期间有线程唤醒立即返回
1.若当前取出的mMessage为空，则将nextPollTimeoutMillis置为-1，然后调用 nativePollOnce(ptr, nextPollTimeoutMillis);会将线程阻塞在这里。
2.若当前取出消息时间还没到，则计算出需要等待时间，阻塞线程
3.将消息的next置为null，给mMessages = msg.next;赋于下一个msg。并将message返回出去。
特别注意
- 1个线程
（Thread）只能绑定 1个循环器（Looper），但可以有多个处理者（Handler） - 1个循环器
（Looper）可绑定多个处理者（Handler） - 1个处理者
（Handler）只能绑定1个1个循环器（Looper）
image
Handler发送消息的两种方式
Handler.post(Runnable r){}
Handler.sendMessage(Message msg){}
image.png
post系列方法传入的Runnable中若持有Context的引用，会造成内存泄漏吗？
显然是会的。Runnable会被封装成Message加入到消息队列中，只要该消息不被处理或者移除，消息队列就会间接持有Context的强引用，造成内存溢出，所以，如果该Handler是针对一个Activity的操作，在Activity的 onDestory()回调函数中中一定要调用removeCallbacksAndMessages()来防止内存泄漏。
