在前一篇文章搞懂Handler的使用与工作流程中讲了下Handler的使用方式，并简单介绍了Handler实现线程通信的流程，这篇文章将继续结合Handler的使用，一步步分析源码看看具体都干了什么，彻底搞清楚Handler，Message，ＭessageQueue以及Looper之间的关系。
平时我们用的最多的可能都是在主线程创建一个Handler对象，然后在子线程利用Handler对象发送消息到主线程处理。现在我们先尝试下在子线程创建Handler，然后在主线程发送消息到子线程，看看能不能行
public class MainActivity extends Activity {
private final static String TAG = "mainActivity";
private static final int MSG1 = 1;
private Handler mHandler;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
new Thread(new Runnable() {
@Override
public void run() {
mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG1:
Log.i(TAG, "主线程发来的消息:" + msg.obj);
break;
default:
break;
}// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();
}
};
}
}).start();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Message msg = Message.obtain();
msg.what = MSG1;
msg.obj = "我是主线程";
mHandler.sendMessage(msg);
}
}
走你，嗯...崩溃得很流畅...
看看日志：
java.lang.RuntimeException: Can't create handler inside thread that has not called Looper.prepare()
at android.os.Handler.<init>(Handler.java:209)
at android.os.Handler.<init>(Handler.java:123)
at com.example.tu.gradletest.MainActivity$1$1.<init>(MainActivity.java:52)
at com.example.tu.gradletest.MainActivity$1.run(MainActivity.java:52)
at java.lang.Thread.run(Thread.java:818)
巴拉巴拉一大串调用栈，但有个核心的提示， Can't create handler inside thread that has not called Looper.prepare()，意思大概就是在线程中还没有调用Looper.prepare()的时候，还不能够创造Handler，那我们就按照提示把这个加上
Looper.prepare();
mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG1:
Log.i(TAG, "主线程发来的消息:" + msg.obj);
break;
default:
break;
}
}
};
再走你，果然不崩溃了，但是log中并没有打印我们想看到的结果。
但是这会儿也没有异常信息了，只能谷歌一下，发现还需要在最后调用一下Looper.loop()，再试一下
Looper.prepare();
mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case MSG1:
Log.i(TAG, "主线程发来的消息:" + msg.obj);
break;
default:
break;
}
}
};
Looper.loop();
这次终于得到了想要的结果
I/mainActivity: 主线程发来的消息:我是主线程
有人可能会问为什么平时在主线程创建Handler的时候不需要加这两步就能用？
这里先解答下这个问题，实际上在主线程也有这两步，只不过不需要我们主动去调用，系统已经帮我们做好了。
下面我就结合上面的使用过程一步步看下源码都干了些什么
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));
}
进入prepare方法发现源码很简单，最终的目的其实就是最后一句，给变量sThreadLocal set了一个Looper对象
sThreadLocal是ThreadLocal类型的，从它调用的get,set方法，我们其实可以理解它是存放数据的，而且当前这个sThreadLocal是存放Looper对象的。ThreadLocal最大的一个特点是它存取的对象是线程隔离的，相当于set的对象与当前调用的线程绑定。
具体的ThreadLocal的原理感兴趣的可以看看源码，本文不作详细分析，不然就可能越说越乱了。
总之，调用Looper.prepare()的作用就是初始化了一个属于当前线程的Looper对象。
接下来再点进去看下Looper对象初始化时又干了些什么事
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
可以看到在构造函数中初始化了一个MessageQueue对象，它实际就是一种先进先出的队列，用于存放需要在线程间通信的Message对象。到这里就完成了让一个线程对应上一个Looper，一个Looper对应上一个MessageQueue。
Looper.prepare之后是Handler的初始化
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) {
Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
klass.getCanonicalName());
}
}
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
初始化过程最终是调用到了上面重载的构造函数中，直接看重点，调用Looper.myLooper()赋值给Handler的Looper类型的成员变量mLooper
看看Looper.myLooper()
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
应该还记得前面调用Looper.prepare()的时候为当前线程初始化了一个Looper对象放在了sThreadLocal中，在这里调用get方法取到了这个Looper对象。
再往下看，对拿到的Looper对象进行了判空，如果为空抛出了一个异常"Can't create handler inside thread that has not called Looper.prepare()"
这个异常信息似曾相识，没错，就是我们在前面demo中还没调用Looper.prepare()时程序崩溃抛出的异常。因为没有调用过prepare方法，当前线程没有对应的Looper对象，自然获取到的为空，但是在主线程，这个方法是在程序初始化时就已经调用过，所以不会崩溃
public static void main(String[] args) {
...
Process.setArgV0("<pre-initialized>");
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
...
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();
}
上面的源码是程序的入口函数ActivityThread的main()函数，可以看到这里调用了Looper.prepareMainLooper()，这个就是专门用来为主线程初始化Looper对象的。
另外还可以看到main函数的最后也同样调用了Looper.loop()方法。
到这里，我们初始化的Handler跟Looper对象关联上了
初始化Handler之后是调用了Looper.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.");
}
final MessageQueue queue = me.mQueue;
// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
// This must be in a local variable, in case a UI event sets the logger
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
final long traceTag = me.mTraceTag;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
final long end;
try {
msg.target.dispatchMessage(msg);
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
...
}
}
这个方法里的代码稍微有些长，不过我们只关心关键的逻辑
首先获取当前线程对应的Looper对象和Looper对应的MessageQueue对象，随后就会开始循环，在循环中会调用MessageQueue对象的next方法，如果没有新消息这个方法会阻塞，若取到了消息，则经过一系列操作之后会调用到msg.target.dispatchMessage(msg)，这一步的作用就是处理消息。
我们都是通过Handler对象发送消息的，所以可以猜想下这个Message对象的target肯定和Handler对象有个什么关系。
下面先看下Handler发送消息的过程
点开mHandler.sendMessage(msg)的源码，发现最后调用到自身的enqueueMessage方法
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
该方法第一句就是给msg的target属性赋值为this，说明target其实就是当前Handler对象。
最后调用到了对应MessageQueue对象的enqueueMessage方法，将发送过来的msg加入队列中。
这个时候在Looper的loop方法中，就会从MessageQueue对象中取出这个message，调用Handler对象的dispatchMessage方法处理消息。
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
在这个方法里，会先判断msg.callback和mCallback是否为空
第一种情况如果都为空的话，最终就会调用handleMessage方法，这个就很熟悉了吧，就是我们在创建Handler对象的时候重写的那个方法，到这，Handler发送消息，到handleMessage处理消息就完成了一次线程间通信。
第二种，当msg.callback和mCallback有不为空的情况时，最终处理消息就不会通过handleMessage方法，那么这两个又是从哪儿来的勒？
我们知道Handler还有种调用post接口的方式，来看下post方法内部的实现
public final boolean post(Runnable r) {
return sendMessageDelayed(getPostMessage(r), 0);
}
实现很简单，直接调用了sendMessageDelayed，这个方法第一个参数是一个Message对象，也就是通过getPostMessage方法将传进去的Runnable对象封装成了一个Message对象，然后sendMessageDelayed也会调用到前面提到的enqueueMessage方法将Message对象加入队列，后面的流程就都一样了
再具体看下怎么把Runnable对象封装成Message对象的
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
很简单，将Runnable对象赋值给了Message对象的callback变量，这样在前面处理信息的方法中msg.callback != null就为true了，会执行handleCallback(msg)方法。
private static void handleCallback(Message message) {
message.callback.run();
}
直接调用了传进去的Runnable对象的run方法处理消息
对于另外一个判断mCallback != null，这个是因为在Handler中有一个重载的构造函数
public Handler(Callback callback) {
this(callback, false);
}
这种方式就很简单了，把处理逻辑放在Callback对象传入Handler中，最后处理消息就会调用这个Callback对象的handleMessage(msg)方法。
到这里，整个Handler从发送消息，到最后处理消息的所有流程就已经分析完了，总结下
图1
如图1，Looper对象与线程1是绑定的关系，创建的Handler对象与这个Looper对象也实现了绑定。在线程2中用这个Handler对象发送一个消息Message对象，这个消息就进入了线程1绑定的Looper对象的MessageQueue队列中，然后线程1中调用的Looper.loop()方法内就会获取到这个消息，把消息交给Handler处理，实现了消息从线程2传递到线程1。
我认为Handler能够实现线程通信的核心可概括为两点：
- 一个Handler对象不是属于某个线程的，在任何线程都可以访问，并发送消息；
- Handler对象的创建必须与Looper对象绑定，这样用这个Handler对象从其他线程发送过来的消息都会在这个Looper对象绑定的线程中处理
Handler对象必须与Looper对象绑定是理解Handler机制的关键点，Handler还有个重载的构造函数，是Handler(Looper looper)，利用这个构造函数，在没有调用过Looper.prepare的线程中初始化Handler就不会报错，可以正常使用，这时Handler处理消息的线程就到了传入的Looper对象绑定的线程中，有兴趣的可以试一下。
目前还在不断学习中，认知有限，若有不对的欢迎指正
网友评论