涉及到的对象：
- Handler
- Message
- MessageQueue
- Looper
Message
一般用法
Message msg = Message.obtain();//存在复用机制,性能好,推荐使用
Message msg = new Message();
Message.obtain()方法：
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
//这里其实是通过使用享元模式,来起到对象复用的,数据结构采用的单链表
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--;
return m;
}
}
return new Message();
}
Handler
一般用法：
Handler handler = new Handler(){
public void handleMessage(Message msg) {
}
};
class MyHandler extends Handler{
public void handleMessage(Message msg) {
}
}
看其构造方法：
public Handler() {
this(null, false);
}
public Handler(Callback callback, boolean async) {
...省略无用代码
//得到当前线程的looper对象
mLooper = Looper.myLooper();
//如果当前线程没有looper对象 则会报异常
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;
}
一般使用sendMessage方法发送消息，其最终调用的是sendMessageAtTime方法：
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
MessageQueue queue = mQueue;
if (queue == null) {
RuntimeException e = new RuntimeException(
this + " sendMessageAtTime() called with no mQueue");
Log.w("Looper", e.getMessage(), e);
return false;
}
return enqueueMessage(queue, msg, uptimeMillis);
}
看enqueueMessage()方法
在Message入队操作中，Message对象持有了当前Handler对象
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
//这个target现在就是当前的Handler
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
Looper
Looper.myLooper()方法：
/**
* Return the Looper object associated with the current thread. Returns
* null if the calling thread is not associated with a Looper.
*/
public static Looper myLooper() {
//使用TreadLocal对象来将Looper对象和创建Handler的线程绑定
//取得时候从当前线程中获取。
return sThreadLocal.get();
}
有取出就有放入，看Looper.prepare()：
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
//同一个线程智能创建一个Looper对象
throw new RuntimeException("Only one Looper may be created per thread");
}
//创建Looper对象和当前线程绑定，new Looper()时便会创建一个MessageQueue消息队列
sThreadLocal.set(new Looper(quitAllowed));
}
再看下方，有一个prepareMainLooper()，顾名思义就是创建主线程的Looper（主线程是默认就存在一个Looper对象，其他线程初始时是没有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();
}
}
为什么主线程默认就有一个Looper对象呢，这里就要追溯到我们应用启动的入口，ActivityThead里的main方法了（这个类SDK中是没有的，需要到系统源码中去找）。
public static final void main(String [] args){
//...省略无用代码
Looper.prepareMainLooper();
if(sMainThreadHandler == null){
sMainTheadHandler = new Handler();
}
//开启死循环检测消息 这句是确保我们的程序一直运行，不会退出
Looper.loop();//
//这里多写一句，当我们主线程的Looper被奇奇怪怪的事情给退出了（结束循环），那么我们的程序也就退出了。
if(Process.supportsProcesses){
throw new RuntimeException("Main thread loop unexpectedly exited");
}
//thread是ActivityThread
thread.detach();
}
这时，主线程中就创建了Looper对象。
再看Looper.loop()方法：
//在此方法中，循环检测消息
public static final void loop(){
Looper me = myLooper();
//此时可能会产生阻塞(队列里没消息)
//产生疑问：假设这里是主线程，产生阻塞却不会触发ANR，搜索发现这和Linux系统里使用管道(pipe)来进行进程间通信有关。
MessageQueue queue = me.mQueue;
while(true){
Message msg = queue.next();
if(msg != null){
//...省略一些判空检测
//Message对象里会持有一个Handler引用，target就是我们的Handler
//调用Handler的dispatchMessage处理消息
msg.target.dispatchMessage(msg);
msg.recycle();//回收消息对象
}
}
}
- 管道通信：Linux中的一种进程间通信方式，使用了特殊的文件，有两个文件描述符（一个是读取，一个是写入）
- 一般应用场景：主进程拿着读取描述符等待读取，没有内容时就会阻塞，另一个进程拿着写入描述符取写数据，此时会唤醒主进程，主进程拿着读取符读取到内容，继续执行。
- Handler应用场景：Looper调用loop方法会产生阻塞，等待消息的到来（此时会主线程会让出cpu，等待被唤醒）。一旦被唤醒，就会将消息取出，交给Handler来处理。（也就是说程序启动，无时无刻伴随着睡眠唤醒，只要你有操作，什么触摸，点击，滑动，所以不会出现卡顿，这也解释了，当你在主线程执行耗时操作，很长时间looper都没有收到消息，也就是没有被唤醒，便会出现ANR异常，我是这么理解的）
最后再看Handler的dispatchMessage方法：
/**
* Handle system messages here.
*/
public void dispatchMessage(Message msg) {
//如果你给Message对象设置了回调 则优先调用
if (msg.callback != null) {
handleCallback(msg);
} else {
//否则查看Handler对象里的回调，也就是执行handler.post之类的方法
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
//当以上都不满足 则调用Hanlder类里的抽象方法 也就是我们一般重写的
handleMessage(msg);
}
}
至此Handler消息机制已经到了尾声，中间略过了消息入队的相关操作，这些操作是在MessageQueue中完成了。有兴趣的小伙伴可以去研究下。
下一篇，我们看一看AsyncTask是怎么工作的。
