Android中HandlerThread類的解析

Android應用中的消息循環由Looper和Handler配合完成，Looper類用於封裝消息循環，類中有個MessageQueue消息隊列；Handler類封裝了消息投遞和消息處理等功能。

系統默認情況下只有主線程（即UI線程）綁定Looper對象，因此在主線程中可以直接創建Handler的實例，但是在子線程中就不能直接new出Handler的實例了，因為子線程默認並沒有Looper對象，此時會拋出RuntimeException異常：

浏覽下Handler的默認構造函數就一目了然了：

1. public Handler() {
2. if (FIND_POTENTIAL_LEAKS) {
3. final Class<? extends Handler> klass = getClass();
4. if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
5. (klass.getModifiers() & Modifier.STATIC) == 0) {
6. Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
7. klass.getCanonicalName());
8. }
9. }
11. mLooper = Looper.myLooper();
12. if (mLooper == null) {
13. throw new RuntimeException(
14. "Can't create handler inside thread that has not called Looper.prepare()");
15. }
16. mQueue = mLooper.mQueue;
17. mCallback = null;
18. }

如果需要在子線程中使用Handler類，首先需要創建Looper類實例，這時可以通過Looper.prepare()和Looper.loop()函數來實現的。閱讀Framework層源碼發現，Android為我們提供了一個HandlerThread類，該類繼承Thread類，並使用上面兩個函數創建Looper對象，而且使用wait/notifyAll解決了多線程中子線程1獲取子線程2的Looper對象為空的問題。HandlerThread類完整代碼如下：

1. /**
2. * Handy class for starting a new thread that has a looper. The looper can then
3. * be used to create handler classes. Note that start() must still be called.
4. */
5. public class HandlerThread extends Thread {
7. private int mPriority; // 線程優先級
9. private int mTid = -1; // 線程ID
11. private Looper mLooper; // 我們需要的Looper對象
13. public HandlerThread(String name) {
14. super(name);
15. mPriority = Process.THREAD_PRIORITY_DEFAULT;
16. }
18. /**
19. * Constructs a HandlerThread.
20. *
21. * @param name
22. * @param priority
23. * The priority to run the thread at. The value supplied must be
24. * from {@link android.os.Process} and not from java.lang.Thread.
25. */
26. public HandlerThread(String name, int priority) {
27. super(name);
28. mPriority = priority;
29. }
31. /**
32. * 在Looper.loop()之前執行動作的回調函數
33. */
34. protected void onLooperPrepared() {
35. }
37. public void run() {
38. mTid = Process.myTid();
39. Looper.prepare(); // 創建本線程的Looper對象
41. synchronized (this) {
42. mLooper = Looper.myLooper();
43. notifyAll(); //通知所有等待該線程Looper對象的其他子線程，本線程的Looper對象已就緒
44. }
46. Process.setThreadPriority(mPriority);
47. onLooperPrepared(); //回調函數
49. Looper.loop(); //開始消息隊列循環
50. mTid = -1;
51. }
53. /**
54. * This method returns the Looper associated with this thread. If this
55. * thread not been started or for any reason is isAlive() returns false,
56. * this method will return null. If this thread has been started, this
57. * method will block until the looper has been initialized.
58. *
59. * @return The looper.
60. */
61. public Looper getLooper() {
62. if (!isAlive()) {
63. return null;
64. }
66. // If the thread has been started, wait until the looper has been
67. // created.
68. synchronized (this) {
69. while (isAlive() && mLooper == null) {
70. try {
71. wait(); //Looper對象未創建好，等待
72. } catch (InterruptedException e) {
73. }
74. }
75. }
76. return mLooper;
77. }
79. /**
80. * Ask the currently running looper to quit. If the thread has not been
81. * started or has finished (that is if {@link #getLooper} returns null),
82. * then false is returned. Otherwise the looper is asked to quit and true is
83. * returned.
84. */
85. public boolean quit() {
86. Looper looper = getLooper();
87. if (looper != null) {
88. looper.quit();
89. return true;
90. }
91. return false;
92. }
94. /**
95. * Returns the identifier of this thread. See Process.myTid().
96. */
97. public int getThreadId() {
98. return mTid;
99. }
100. }