- 目录
- Handler、Looper、MessageQueue源码解析——Handler
- Handler、Looper、MessageQueue源码解析——Looper
- Handler、Looper、MessageQueue源码解析——ThreadLocal
- Handler、Looper、MessageQueue源码解析——MessageQueue
Looper
在Handler的构造函数中有这样一行代码：
mLooper = Looper.myLooper();
Looper是干什么的呢？
Looper负责创建一个MessageQueue，然后开启消息循环，不断的从MessageQueue取出消息，再交给Handler来处理消息。
Looper中两个最重要的方法是prepare()和loop()，我们分别来看看这两个方法的实现。
当我们要创建一个Looper对象时，我们要调用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));
}```
sThreadLocal 是一个ThreadLocal对象，ThreadLocal以key-value的方式储存变量，并保证该变量线程间互不影响。prepare()方法在调用了set方法把一个new Looper对象存进去，所以可以看出prepare()方法只能调用一次，否则sThreadLocal不为空会抛出Exception。接下来进入到Looper的构造方法，一探究竟。
``` java
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
private static Looper sMainLooper; // guarded by Looper.class
final MessageQueue mQueue;
final Thread mThread;
...
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
在构造方法中新建的一个MessageQueue，并获取当前Thread对象。
在Handler构造方法中调用了Looper的myLooper()方法：
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
可以看出myLooper()方法通过ThreadLocal获取当前的线程的Looper对象，回到Handler的构造函数
public Handler(Callback callback, boolean async) {
...
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
...
}```
如果myLooper得到的Looper对象为空，则会抛出异常，也就是说在新线程我们如果要创建一个Handler必须要调用Looper.prepare()。那么，为什么我们在主线程不需要调用prepare()方法呢？
那是因为在ActivityThread中主线程的Looper已经开启：
public static void main(String[] args) {
...
Looper.prepareMainLooper();
...
}```
在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();
}
}```
所以在主线程再次调用prepareMainLooper()同样会报错。
再看Looper另外一个重要的方法，loop()：
``` java
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;
...
for (;;) {
// 从MessageQueue中不断取出消息
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
...
try {
//调用Handler的dispatchMessage (msg)方法
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
...
msg.recycleUnchecked();
}
}```
可以看到，loop()方法是一个死循环，从MessageQueue中不断取出消息，然后调用handler的dispatchMessage(msg)方法，交给Handler来处理消息。直到消息队列为空才能结束循环，当然，我们也是可以手动结束消息循环的，Looper提供了两个方法：
public void quit() {
mQueue.quit(false);
}
public void quitSafely() {
mQueue.quit(true);
}```
调用MessageQueue的quit方法：
void quit(boolean safe) {
if (!mQuitAllowed) {
throw new IllegalStateException("Main thread not allowed to quit.");
}
synchronized (this) {
if (mQuitting) {
return;
}
mQuitting = true;
if (safe) {
removeAllFutureMessagesLocked();
} else {
removeAllMessagesLocked();
}
// We can assume mPtr != 0 because mQuitting was previously false.
nativeWake(mPtr);
}
}```
>当我们调用Looper的quit方法时，实际上执行了MessageQueue中的removeAllMessagesLocked方法，该方法的作用是把MessageQueue消息池中所有的消息全部清空，无论是延迟消息（延迟消息是指通过sendMessageDelayed或通过postDelayed等方法发送的需要延迟执行的消息）还是非延迟消息。
>当我们调用Looper的quitSafely方法时，实际上执行了MessageQueue中的removeAllFutureMessagesLocked方法，通过名字就可以看出，该方法只会清空MessageQueue消息池中所有的延迟消息，并将消息池中所有的非延迟消息派发出去让Handler去处理，quitSafely相比于quit方法安全之处在于清空消息之前会派发所有的非延迟消息。
具体实现我会在后面的MessageQueue中讲到。
以上就是Looper的大部分源码解析，读到这我们应该能大致知道Handler、Looper、MessageQueue消息处理机制大致是一个怎样的流程了。在Looper的源码中，我们遇到了一个新的东西——ThreadLocal，接下来我会带来ThreadLocal的源码分析。