Android handler

http://www.cnblogs.com/tt_mc/archive/2012/01/30/2331876.html

http://blog.youkuaiyun.com/lifeijiyuan126/article/details/7657839

Android UI 单线程模型

http://blog.youkuaiyun.com/luoshengyang/article/details/6905587

Android Looper和Handler分析

http://blog.youkuaiyun.com/Innost/article/details/6055793

Looper

from http://blog.youkuaiyun.com/luoshengyang/article/details/6817933

   Android应用程序是通过消息来驱动的，系统为每一个应用程序维护一个消息队例，应用程序的主线程不断地从这个消息队例中获取消息（Looper），然后对这些消息进行处理（Handler），这样就实现了通过消息来驱动应用程序的执行.

ActivityManagerService需要与应用程序进行并互时，如加载Activity和Service、处理广播待，会通过Binder进程间通信机制来知会应用程序，应用程序接收到这个请求时，它不是马上就处理这个请求，而是将这个请求封装成一个消息，然后把这个消息放在应用程序的消息队列中去，然后再通过消息循环来处理这个消息。这样做的好处就是消息的发送方只要把消息发送到应用程序的消息队列中去就行了，它可以马上返回去处理别的事情，而不需要等待消息的接收方去处理完这个消息才返回，这样就可以提高系统的并发性。实质上，这就是一种异步处理机制。

  在消息处理机制中，消息都是存放在一个消息队列中去，而应用程序的主线程就是围绕这个消息队列进入一个无限循环的，直到应用程序退出。如果队列中有消息，应用程序的主线程就会把它取出来，并分发给相应的Handler进行处理；如果队列中没有消息，应用程序的主线程就会进入空闲等待状态，等待下一个消息的到来

1. public final class ActivityThread {  
2.     ......  
3.   
4.     public static final void main(String[] args) {  
5.         ......  
6.   
7.         Looper.prepareMainLooper();  
8.   
9.         ......  
10.   
11.         ActivityThread thread = new ActivityThread();  
12.         thread.attach(false);  
13.           
14.         ......  
15.   
16.         Looper.loop();  
17.   
18.         ......  
19.   
20.         thread.detach();  
21.   
22.         ......  
23.     }  
24. } 
    

1. public class Looper {  
2.     ......  
3.   
4.     private static final ThreadLocal sThreadLocal = new ThreadLocal();  
5.   
6.     final MessageQueue mQueue;  
7.   
8.     ......  
9.   
10.     /** Initialize the current thread as a looper. 
11.     * This gives you a chance to create handlers that then reference 
12.     * this looper, before actually starting the loop. Be sure to call 
13.     * {@link #loop()} after calling this method, and end it by calling 
14.     * {@link #quit()}. 
15.     */  
16.     public static final void prepare() {  
17.         if (sThreadLocal.get() != null) {  
18.             throw new RuntimeException("Only one Looper may be created per thread");  
19.         }  
20.         sThreadLocal.set(new Looper());  
21.     }  
22.   
23.     /** Initialize the current thread as a looper, marking it as an application's main  
24.     *  looper. The main looper for your application is created by the Android environment, 
25.     *  so you should never need to call this function yourself. 
26.     * {@link #prepare()} 
27.     */  
28.   
29.     public static final void prepareMainLooper() {  
30.         prepare();  
31.         setMainLooper(myLooper());  
32.         if (Process.supportsProcesses()) {  
33.             myLooper().mQueue.mQuitAllowed = false;  
34.         }  
35.     }  
36.   
37.     private synchronized static void setMainLooper(Looper looper) {  
38.         mMainLooper = looper;  
39.     }  
40.   
41.     /** 
42.     * Return the Looper object associated with the current thread.  Returns 
43.     * null if the calling thread is not associated with a Looper. 
44.     */  
45.     public static final Looper myLooper() {  
46.         return (Looper)sThreadLocal.get();  
47.     }  
48.   
49.     private Looper() {  
50.         mQueue = new MessageQueue();  
51.         mRun = true;  
52.         mThread = Thread.currentThread();  //默认属于当前所在的线程
53.     }  
54.   
55.     ......  
56. }  

        函数prepareMainLooper做的事情其实就是在线程中创建一个Looper对象，这个Looper对象是存放在sThreadLocal成员变量里面的，成员变量sThreadLocal的类型为ThreadLocal，表示这是一个线程局部变量，即保证每一个调用了prepareMainLooper函数的线程里面都有一个独立的Looper对象。在线程是创建Looper对象的工作是由prepare函数来完成的，而在创建Looper对象的时候，会同时创建一个消息队列MessageQueue，保存在Looper的成员变量mQueue中，后续消息就是存放在这个队列中去。消息队列在Android应用程序消息处理机制中最重要的组件.

就调用Looper类的loop函数进入到消息循环中去了：

[cpp] view plain copy

1. public class Looper {  
2.     ......  
3.   
4.     public static final void loop() {  
5.         Looper me = myLooper();  
6.         MessageQueue queue = me.mQueue;  
7.   
8.         ......  
9.   
10.         while (true) {  
11.             Message msg = queue.next(); // might block  
12.             ......  
13.   
14.             if (msg != null) {  
15.                 if (msg.target == null) {  
16.                     // No target is a magic identifier for the quit message.  
17.                     return;  
18.                 }  
19.   
20.                 ......  
21.   
22.                 msg.target.dispatchMessage(msg);  
23.                   
24.                 ......  
25.   
26.                 msg.recycle();  
27.             }  
28.         }  
29.     }  
30.   
31.     ......  
32. }  

        这里就是进入到消息循环中去了，它不断地从消息队列mQueue中去获取下一个要处理的消息msg，如果消息的target成员变量为null，就表示要退出消息循环了，否则的话就要调用这个target对象的dispatchMessage成员函数来处理这个消息，这个target对象的类型为Handler，下面我们分析消息的发送时会看到这个消息对象msg是如设置的。