首先Handler大概的工作流程我们要了解一下：
image.png
下面这几个类很重要：
- Handler 发送Message和处理消息（Message）
- Looper 轮询，不断的从Messagequeue队列中取消息（Message ）
- MessageQueue 存放消息的队列（单链表），要处理的Message就放在这里面
- ThreadLocal 存放Looper的容器
从Handler 到 MessageQueue
从handler.sendMessage()开始，点进去看一下，最终会调用到 Handler.enqueueMessage()方法，而且这个方法最后是调用了MessageQueue.enqueueMessage这个方法，并且使用了synchronized来保证多线程同时操作，通过判断延迟时间来确认消息插入到哪，所以这个MessageQueue队列中的Message是有顺序的
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
long uptimeMillis) {
msg.target = this;
msg.workSourceUid = ThreadLocalWorkSource.getUid();
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
//MessageQueue.java
boolean enqueueMessage(Message msg, long when) {
if (msg.target == null) {
throw new IllegalArgumentException("Message must have a target.");
}
// 避免多线程同时操作
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 {
// 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;
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;
}
上面就是从Handler——>MessageQueue的过程
接下来Looper
每个线程只有一个Looper，那么他是怎么做到的呢？
先从new Handler()开始看起，先不加static关键字
private /**static*/ final Handler handler = new Handler(Looper.myLooper(), new Handler.Callback() {
@Override
public boolean handleMessage(@NonNull Message msg) {
return false;
}
});
先看一下Looper.myLooper()方法,这个方法是从ThreadLocal中获取一个Looper对象，那么这个Looper是什么时候创建的呢，又是如何获取的呢？
- 在
perpare()方法中保证了每个线程只能有一个Looper，当我们创建多个Looper的时候就会抛出异常Only one Looper may be created per thread” -
sThreadLocal.set(new Looper(quitAllowed));首先调用ThreadLocal的set方法并且传入一个Looper对象 - ThreadLocal中set() 方法，获取当前线程，并且拿到当前线程中的ThreadLocalMap，然后
map.set(this, value)这句话，是将ThreadLocal作为key ,Looper对象作为value，并存入到ThreadLocalMap中
Looper.java
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
//创建Looper
private static void prepare(boolean quitAllowed) {
//保证一个线程中只有一个Looper
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
//获取Looper
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
ThreadLocal.java
public void set(T value) {
Thread t = Thread.currentThread();
//获取当线程的ThreadLocalMap
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
//从当前线程的ThreadLocalMap中获取ThreadLocal，这个ThreadLocal中就包含着Looper
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
//这个Entry就是相当于ThreadLocal，他其实是一个弱引用WeakReference<ThreadLocal>
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
//e.value是获取的 Looper，如果是e.get()返回的是ThreadLocal
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
ThreadLocal.get() 首先获取到当前线程，从当前线程中拿到ThreadLocalMap,这个map是ThreadLocal中的静态内部类，而且这个ThreadLocalMap中保存的就是ThreadLocal和Looper
注：ThreadLocalMap 的数据结构和HasMap类似
static class ThreadLocalMap {
static class Entry extends WeakReference<ThreadLocal<?>> {
...省略内部代码
/**
* Get the entry associated with key. This method
* itself handles only the fast path: a direct hit of existing
* key. It otherwise relays to getEntryAfterMiss. This is
* designed to maximize performance for direct hits, in part
* by making this method readily inlinable.
*
* @param key the thread local object
* @return the entry associated with key, or null if no such
*/
private Entry getEntry(ThreadLocal<?> key) {
int i = key.threadLocalHashCode & (table.length - 1);
Entry e = table[i];
if (e != null && e.get() == key)
return e;
else
return getEntryAfterMiss(key, i, e);
}
}
}
Looper中的loop()方法对MessageQueue队列的轮询,可以看到通过MessageQueue.next取出Message，并且调用msg.target.dispatchMessage(msg); 进行消息的分发，那么msg.target是什么呢？
在Handler 的 enqueueMessage（）方法(所有的sendMessage最后都会调用到这个方法)中有这么一句话msg.target = this; ，这里的this就是我们Activity或者子线程中的handler
我们的handler是Activity中的内部类，因为内部类会持有外部类的引用，所以这里Message中包含着handle自然也会有Activity的引用，这也是为什么当我们的Handler流程没有执行完时Activity关闭了会造成内存泄漏
/**
* Run the message queue in this thread. Be sure to call
* {@link #quit()} to end the loop.
*/
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
for (;;) {
//取出队列中的Message
Message msg = queue.next(); // might block
... 省略部分代码
try {
//Message中的target就是handler,所以此处调用的是Handler中的dispatchMessage()方法
msg.target.dispatchMessage(msg);
if (observer != null) {
observer.messageDispatched(token, msg);
}
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} catch (Exception exception) {
} finally {
}
msg.recycleUnchecked();
}
}
还有一个就是我们的延时消息是如何发送的。这就要看一下我们 MessageQueue中的next()方法了
next()的部分源码 ，这里也用到了 synchronized 防止多线程同时操作
延时消息是通过判断这条消息的时间(when)是否比现在时间大，如果大说明还没到该处理的时间，如果小就返回这个Message并返回到Looper的loop()方法中，然后再由handler去分发
- when 在我们sendMessage时
when = SystemClock.uptimeMillis() + delayMillis()（当前时间+需要延时的时间）
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) {
//判断这条消息的时间是否比现在时间大，如果大说明还没到该处理的时间，
// 如果小就返回这个Message并返回到Looper的loop()方法中，然后再由handler去分发
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;
}
// Process the quit message now that all pending messages have been handled.
if (mQuitting) {
dispose();
return null;
}
｝
网友评论