消息机制之Looper

Android消息机制中，Looper处于核心地位，它类似于一个消息泵，不断从MessageQueue中读取数据，然后分发给Handler去处理。 
一、官方建议的使用形式： 

Java代码  

1. class LooperThread extends Thread {  
2.     public Handler mHandler;  
3.   
4.     public void run() {  
5.         Looper.prepare();  
6.   
7.         mHandler = new Handler() {  
8.             public void handleMessage(Message msg) {  
9.                 // process incoming messages here  
10.             }  
11.         };  
12.   
13.         Looper.loop();  
14.     }  
15. }  

二、Looper源码阅读： 
上述子线程中调用了Looper.prepare()和Looper.loop()到底做了什么事情？ 
1、先看prepare()方法： 

Java代码  

1. public static void prepare() {  
2.     if (sThreadLocal.get() != null) {  
3.         throw new RuntimeException("Only one Looper may be created per thread");  
4.     }  
5.     sThreadLocal.set(new Looper());  
6. }  

prepare是一个静态方法，那就意味着可以直接通过类名访问，这个方法只做了一件事，就是创建一个Looper对象，把这个对象放到sThreadLocal中。在创建之前会判断sThreadLocal是否为空，即保证当前只有一个Looper对象。 

那创建Looper对象时做了什么事情呢？ 

Java代码  

1. private Looper() {  
2.     mQueue = new MessageQueue();  
3.     mRun = true;  
4.     mThread = Thread.currentThread();  
5. }  

创建一个消息队列； 
设置run运行变量； 
跟当前线程绑定； 


2、loop方法： 

Java代码  

1. public static void loop() {  
2.  while (true) {  
3.             Message msg = queue.next(); // might block  
4.             if (msg != null) {  
5.                 if (msg.target == null) {  
6.                     // No target is a magic identifier for the quit message.  
7.                     return;  
8.                 }  
9. msg.target.dispatchMessage(msg);  
10. msg.recycle();  
11. }  
12. }  

上述方法只截取了部分，可见也是一个静态方法，做的事情也很简单，很单调： 
不停的检查MessageQueue，拿到Message，根据Message的target将消息分发给Handler，分发完成之后回收消息； 
msg.target是handler，这句话是在looper中执行的，然后进入dispatchMessage(msg），也就是说，handler的dispatchMessage(msg)这个方法是在looper的线程中执行的，二dispatchMessage就会执行handler 的handlerMessage方法了，这个显然是在looper的线程中执行的了。 

总之，handler的线程就是提供下handler这个实例变量而已，而真正循环处理消息的线程是looper所在的线程了。 

3、setMainLooper和getMainLooper方法可以存取主线程的Looper对象。 

总结： 
Thread和Looper是一一对应关系。 
Thread和MessageQueue也是是一一对应关系。 
俗一点说：一个Thread只有一个Looper对象，一个MessageQueue对象； 
Looper分发消息是阻塞式的（might block），即一个消息分发完成之后才会处理下一个消息； 
“Looper就是一个While循环，不停的从MessageQueue读取Message并分发给Handler处理，而调用Looper.loop()启动了循环”