Android中的Looper，Handler及HandlerThread简析

阅读更多

Can’t create handler inside thread that has not called Looper.prepare()

毕业后在深圳一家公司工作，目前公司在做的是与android相关的项目，有Android源码。
这几周，出现几次同事在使用Handler的时候，在调用时抛出RuntimeException的错误，异常消息如下：Can’t create handler inside thread that has not called Looper.prepare() ，代码是在Handler handler = new Handler()的这一行。

以下内容是我的理解，如果理解有误，还请指出以便修正，以免我误导到他人。


那么这个问题要怎么解决呢？
从异常信息来看，是说在线程里创建Handler对象前没有调用Looper.prepare()方法。
首先，我们得知道，Looper是用来为线程创建一个消息循环的。而在Thread对象当中，默认是不与Looper绑定的，也就是默认是没有Looper对象的。
Android当中，对线程和消息队列进行了封装，即Handler类。它是一个可以用来处理循环消息队列的线程对象，在其构造方法中，部分代码如下（正好公司项目里有android源码，就看下代码吧，在frameworkd/base/core/java/android/os/下）：

110     public Handler() {
111         this(null, false);
112     }
...
144     public Handler(Looper looper, Callback callback) {
145         this(looper, callback, false);
146     }
...
185     public Handler(Callback callback, boolean async) {
186         if (FIND_POTENTIAL_LEAKS) {
187             final Class klass = getClass();
188             if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
189                     (klass.getModifiers() & Modifier.STATIC) == 0) {
190                 Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
191                     klass.getCanonicalName());
192             }
193         }
194 
195         mLooper = Looper.myLooper();
196         if (mLooper == null) {
197             throw new RuntimeException(
198                 "Can't create handler inside thread that has not called Looper.prepare()");
199         }
200         mQueue = mLooper.mQueue;
201         mCallback = callback;
202         mAsynchronous = async;
203     }

它通过调用Looper.myLooper()来获取当前线程的Looper对象，如果获取的Looper对象为null，就抛出这个异常了。这里顺便说一下一个误区，我发现有一些人会以为Handler就是一个多了消息队列的Thread，以为Handler handler = new Handler()，会创建一个新线程。其实并不是的，上面已经提到，Handler通过无参构造方法构造出来的对象，使用的是当前线程的Looper对象，所以通过它执行的代码，其实是在当前进程执行。
既然如此，那么我就想到解决的方法了。就是通过HandlerThread类。代码如下：

HandlerThread t = new HandlerThread("test");
t.start();
Handler handler = new Handler(t.getLooper());

果然问题解决。这里构造的Handler对象，它是在一个新的线程当中执行的。

现在再来看看，Looper.myLooper()方法，代码如下：

162     public static Looper myLooper() {
163         return sThreadLocal.get();
164     }

通过调用ThreadLocal对象的get()方法来返回Looper对象。
声明代码在Looper类当中，如下：

 56     // sThreadLocal.get() will return null unless you've called prepare().
 57     static final ThreadLocal sThreadLocal = new ThreadLocal();

上面提到，Looper对象是用来为线程执行一个消息循环的，而本身具备消息队列的Handler需要有一个Looper对象，所以它会提示你要在创建Handler对象前调用Looper.prepare()方法。该方法代码如下：

 66      /** Initialize the current thread as a looper.
 67       * This gives you a chance to create handlers that then reference
 68       * this looper, before actually starting the loop. Be sure to call
 69       * {@link #loop()} after calling this method, and end it by calling
 70       * {@link #quit()}.
 71       */
 72     public static void prepare() {
 73         prepare(true);
 74     }
 75 
 76     private static void prepare(boolean quitAllowed) {
 77         if (sThreadLocal.get() != null) {
 78             throw new RuntimeException("Only one Looper may be created per thread");
 79         }
 80         sThreadLocal.set(new Looper(quitAllowed));
 81     }

该方法创建一个Looper对象，再存入ThreadLocal对象。调用它之后，再在Thread中创建Handler对象，也就不会有获取到的Looper对象为null的异常了。

但是在这里我还有疑问，疑问如下：
1，ThreadLocal是什么？
2，Handler和Looper如何实现消息循环队列？
3，HandlerThread在什么时候创建一个Looper对象？

于是继续探索。
查java api可知，ThreadLocal提供了线程局部变量，所以通过它来保存当前线程的消息循环队列Looper对象是再合适不过的了。

对于第二个问题，我们可以看Looper类的声明，代码如下：

 53 public class Looper {
 54     private static final String TAG = "Looper";
 55 
 56     // sThreadLocal.get() will return null unless you've called prepare().
 57     static final ThreadLocal sThreadLocal = new ThreadLocal();
 58     private static Looper sMainLooper;  // guarded by Looper.class
 59 
 60     final MessageQueue mQueue;
 61     final Thread mThread;
 62     volatile boolean mRun;
 63 
 64     private Printer mLogging;
 65 
        ...
    }

里面有一个消息队列，要发送的消息都通过Handler被加入在里面。而在Looper类当中，则通过loop方法里的死循环，不断地去读这个消息队列，代码如下：

107     /**
108      * Run the message queue in this thread. Be sure to call
109      * {@link #quit()} to end the loop.
110      */
111     public static void loop() {
112         final Looper me = myLooper();
113         if (me == null) {
114             throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
115         }
116         final MessageQueue queue = me.mQueue;
117 
118         // Make sure the identity of this thread is that of the local process,
119         // and keep track of what that identity token actually is.
120         Binder.clearCallingIdentity();
121         final long ident = Binder.clearCallingIdentity();
122 
123         for (;;) {
124             Message msg = queue.next(); // might block
125             if (msg == null) {
126                 // No message indicates that the message queue is quitting.
127                 return;
128             }
129 
130             // This must be in a local variable, in case a UI event sets the logger
131             Printer logging = me.mLogging;
132             if (logging != null) {
133                 logging.println(">>>>> Dispatching to " + msg.target + " " +
134                         msg.callback + ": " + msg.what);
135             }
136 
137             msg.target.dispatchMessage(msg);
138 
139             if (logging != null) {
140                 logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
141             }
142 
143             // Make sure that during the course of dispatching the
144             // identity of the thread wasn't corrupted.
145             final long newIdent = Binder.clearCallingIdentity();
146             if (ident != newIdent) {
147                 Log.wtf(TAG, "Thread identity changed from 0x"
148                         + Long.toHexString(ident) + " to 0x"
149                         + Long.toHexString(newIdent) + " while dispatching to "
150                         + msg.target.getClass().getName() + " "
151                         + msg.callback + " what=" + msg.what);
152             }
153 
154             msg.recycle();
155         }
156     }

那么，哪里会调用Looper.loop()方法呢？我在frameworks/base/core/java/android/os目录下搜了一下，结果如下：

phoenix@rtkPhoenix:~/branch/workspace/kernel/android/JB/frameworks/base/core/java/android$ jgrep "loop()"
./app/ActivityThread.java:5039:        Looper.loop();
./os/Looper.java:49:  *          Looper.loop();
./os/Looper.java:69:      * {@link #loop()} after calling this method, and end it by calling
./os/Looper.java:111:    public static void loop() {
./os/HandlerThread.java:60:        Looper.loop();
./webkit/WebSyncManager.java:90:        Looper.loop();
./webkit/WebCoreThreadWatchdog.java:224:        Looper.loop();
./webkit/WebViewCore.java:812:            Looper.loop();

主线程的Looper对象的loop()通过ActivityThread来调用，ActivityThread是程序的入口，其提供了main静态方法。当loop()被调用之后，它便通过一个死循环不断读取消息队列中的对象(调用 MessageQueue.next()方法），直到它读取到的Message对象为null。通过调用Looper.quit()方法可以退出，因为该方法会调用消息队列的quit()方法，而消息队列MessageQueue对象当退出时会在next()方法中返回null。

而对于HandlerThread调用loop()方法，将在下面谈。

下面说一下HandlerThread类。HandlerThread类用来开启一个含Looper对象的线程。它继承自Thread，在run()方法中调用Looper.prepare()来初始化Looper对象。代码如下：

 51     public void run() {
 52         mTid = Process.myTid();
 53         Looper.prepare();
 54         synchronized (this) {
 55             mLooper = Looper.myLooper();
 56             notifyAll();
 57         }
 58         Process.setThreadPriority(mPriority);
 59         onLooperPrepared();
 60         Looper.loop();
 61         mTid = -1;
 62     }

在run方法中调用Looper.prepare()，所以这也就是在上面代码中，为什么对HandlerThread对象调用start()方法之后，才去获得它的looper来创建Handler对象。而HandlerThread对象也在run方法结束前，调用Looper.loop()方法，开始消息循环。