Android Looper和Handler分析

第一次接觸Android應用程序（這裡指的是JAVA層的UI程序，也難怪了，Google放出的API就只支持JAVA應用程序了），很難搞明白內部是如何實現的。但是，從原理上分析，應該是有一個消息循環，一個消息隊列，然後主線程不斷得從消息隊列中取得消息並處理之。

然而，google封裝得太厲害了，所以一時半會還是搞不清楚到底是怎麼做的。本文將分析android內的looper，這個是用來封裝消息循環和消息隊列的一個類，handler其實可以看做是一個工具類，用來向消息隊列中插入消息的。好比是Windows API的SendMessage中的HANDLE，這個handle是窗口句柄。

1. //Looper類分析   
2. //沒找到合適的分析代碼的辦法，只能這麼來了。每個重要行的上面都會加上注釋   
3. //功能方面的代碼會在代碼前加上一段分析   
4. public class Looper {  
5.    //static變量，判斷是否打印調試信息。   
6.     private static final boolean DEBUG = false;  
7.     private static final boolean localLOGV = DEBUG ? Config.LOGD : Config.LOGV;  
8.   
9.     // sThreadLocal.get() will return null unless you've called prepare().   
10. //線程本地存儲功能的封裝，TLS，thread local storage,什麼意思呢？因為存儲要麼在棧上，例如函數內定義的內部變量。要麼在堆上，例如new或者malloc出來的東西   
11. //但是現在的系統比如Linux和windows都提供了線程本地存儲空間，也就是這個存儲空間是和線程相關的，一個線程內有一個內部存儲空間，這樣的話我把線程相關的東西就存儲到   
12. //這個線程的TLS中，就不用放在堆上而進行同步操作了。   
13.     private static final ThreadLocal sThreadLocal = new ThreadLocal();  
14. //消息隊列，MessageQueue，看名字就知道是個queue..   
15.     final MessageQueue mQueue;  
16.     volatile boolean mRun;  
17. //和本looper相關的那個線程，初始化為null   
18.     Thread mThread;  
19.     private Printer mLogging = null;  
20. //static變量，代表一個UI Process（也可能是service吧，這裡默認就是UI）的主線程   
21.     private static Looper mMainLooper = null;  
22.       
23.      /** Initialize the current thread as a looper. 
24.       * This gives you a chance to create handlers that then reference 
25.       * this looper, before actually starting the loop. Be sure to call 
26.       * {@link #loop()} after calling this method, and end it by calling 
27.       * {@link #quit()}. 
28.       */  
29. //往TLS中設上這個Looper對象的，如果這個線程已經設過了ｌｏｏｐｅｒ的話就會報錯   
30. //這說明，一個線程只能設一個looper   
31.     public static final void prepare() {  
32.         if (sThreadLocal.get() != null) {  
33.             throw new RuntimeException("Only one Looper may be created per thread");  
34.         }  
35.         sThreadLocal.set(new Looper());  
36.     }  
37.       
38.     /** Initialize the current thread as a looper, marking it as an application's main  
39.      *  looper. The main looper for your application is created by the Android environment, 
40.      *  so you should never need to call this function yourself. 
41.      * {@link #prepare()} 
42.      */  
43.  //由framework設置的UI程序的主消息循環，注意，這個主消息循環是不會主動退出的   
44. //       
45.     public static final void prepareMainLooper() {  
46.         prepare();  
47.         setMainLooper(myLooper());  
48. //判斷主消息循環是否能退出....   
49. //通過quit函數向looper發出退出申請   
50.         if (Process.supportsProcesses()) {  
51.             myLooper().mQueue.mQuitAllowed = false;  
52.         }  
53.     }  
54.   
55.     private synchronized static void setMainLooper(Looper looper) {  
56.         mMainLooper = looper;  
57.     }  
58.       
59.     /** Returns the application's main looper, which lives in the main thread of the application. 
60.      */  
61.     public synchronized static final Looper getMainLooper() {  
62.         return mMainLooper;  
63.     }  
64.   
65.     /** 
66.      *  Run the message queue in this thread. Be sure to call 
67.      * {@link #quit()} to end the loop. 
68.      */  
69. //消息循環，整個程序就在這裡while了。   
70. //這個是static函數喔！   
71.     public static final void loop() {  
72.         Looper me = myLooper();//從該線程中取出對應的looper對象   
73.         MessageQueue queue = me.mQueue;//取消息隊列對象...   
74.         while (true) {  
75.             Message msg = queue.next(); // might block取消息隊列中的一個待處理消息..   
76.             //if (!me.mRun) {//是否需要退出？mRun是個volatile變量，跨線程同步的，應該是有地方設置它。   
77.             //    break;   
78.             //}   
79.             if (msg != null) {  
80.                 if (msg.target == null) {  
81.                     // No target is a magic identifier for the quit message.   
82.                     return;  
83.                 }  
84.                 if (me.mLogging!= null) me.mLogging.println(  
85.                         ">>>>> Dispatching to " + msg.target + " "  
86.                         + msg.callback + ": " + msg.what  
87.                         );  
88.                 msg.target.dispatchMessage(msg);  
89.                 if (me.mLogging!= null) me.mLogging.println(  
90.                         "<<<<< Finished to    " + msg.target + " "  
91.                         + msg.callback);  
92.                 msg.recycle();  
93.             }  
94.         }  
95.     }  
96.   
97.     /** 
98.      * Return the Looper object associated with the current thread.  Returns 
99.      * null if the calling thread is not associated with a Looper. 
100.      */  
101. //返回和線程相關的looper   
102.     public static final Looper myLooper() {  
103.         return (Looper)sThreadLocal.get();  
104.     }  
105.   
106.     /** 
107.      * Control logging of messages as they are processed by this Looper.  If 
108.      * enabled, a log message will be written to <var>printer</var>  
109.      * at the beginning and ending of each message dispatch, identifying the 
110.      * target Handler and message contents. 
111.      *  
112.      * @param printer A Printer object that will receive log messages, or 
113.      * null to disable message logging. 
114.      */  
115. //設置調試輸出對象，looper循環的時候會打印相關信息，用來調試用最好了。   
116.     public void setMessageLogging(Printer printer) {  
117.         mLogging = printer;  
118.     }  
119.       
120.     /** 
121.      * Return the {@link MessageQueue} object associated with the current 
122.      * thread.  This must be called from a thread running a Looper, or a 
123.      * NullPointerException will be thrown. 
124.      */  
125.     public static final MessageQueue myQueue() {  
126.         return myLooper().mQueue;  
127.     }  
128. //創建一個新的looper對象，   
129. //內部分配一個消息隊列，設置mRun為true   
130.     private Looper() {  
131.         mQueue = new MessageQueue();  
132.         mRun = true;  
133.         mThread = Thread.currentThread();  
134.     }  
135.   
136.     public void quit() {  
137.         Message msg = Message.obtain();  
138.         // NOTE: By enqueueing directly into the message queue, the   
139.         // message is left with a null target.  This is how we know it is   
140.         // a quit message.   
141.         mQueue.enqueueMessage(msg, 0);  
142.     }  
143.   
144.     /** 
145.      * Return the Thread associated with this Looper. 
146.      */  
147.     public Thread getThread() {  
148.         return mThread;  
149.     }  
150.     //後面就簡單了，打印，異常定義等。   
151.     public void dump(Printer pw, String prefix) {  
152.         pw.println(prefix + this);  
153.         pw.println(prefix + "mRun=" + mRun);  
154.         pw.println(prefix + "mThread=" + mThread);  
155.         pw.println(prefix + "mQueue=" + ((mQueue != null) ? mQueue : "(null"));  
156.         if (mQueue != null) {  
157.             synchronized (mQueue) {  
158.                 Message msg = mQueue.mMessages;  
159.                 int n = 0;  
160.                 while (msg != null) {  
161.                     pw.println(prefix + "  Message " + n + ": " + msg);  
162.                     n++;  
163.                     msg = msg.next;  
164.                 }  
165.                 pw.println(prefix + "(Total messages: " + n + ")");  
166.             }  
167.         }  
168.     }  
169.   
170.     public String toString() {  
171.         return "Looper{"  
172.             + Integer.toHexString(System.identityHashCode(this))  
173.             + "}";  
174.     }  
175.   
176.     static class HandlerException extends Exception {  
177.   
178.         HandlerException(Message message, Throwable cause) {  
179.             super(createMessage(cause), cause);  
180.         }  
181.   
182.         static String createMessage(Throwable cause) {  
183.             String causeMsg = cause.getMessage();  
184.             if (causeMsg == null) {  
185.                 causeMsg = cause.toString();  
186.             }  
187.             return causeMsg;  
188.         }  
189.     }  
190. }