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<? extends Handler> 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 call109      * {@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 block125             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 logger131             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 the144             // 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()方法，开始消息循环。

更多相关文章

随机推荐