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;
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;
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. }
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. }
55. private synchronized static void setMainLooper(Looper looper) {
56. mMainLooper = looper;
57. }
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. }
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. }
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. }
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. }
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. }
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. }
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. }
170. public String toString() {
171. return "Looper{"
172. + Integer.toHexString(System.identityHashCode(this))
173. + "}";
174. }
176. static class HandlerException extends Exception {
178. HandlerException(Message message, Throwable cause) {
179. super(createMessage(cause), cause);
180. }
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. }