子线程新建Handler为什么会报错？——浅谈Handler、Looper、Message关系

转载注明出处：

http://blog.csdn.net/u010181592/article/category/5893483

文章出自我不只是看客的博客

很多人都知道不能直接在子线程new 一个Handler，android会报错，至于为什么会报错，并没有做深入的研究，今天就来研究一下，顺手学习了下android异步消息处理机制的问题，一起放出来。

列出参考资料：
Android 异步消息处理机制让你深入理解 Looper、Handler、Message三者关系出自鸿洋大神的博客；

常见面试题

在子线程中new一个Handler为什么报错？

下边来重现一下错误的做法：

首先，直接在子线程新建一个handler

new Thread(new Runnable() {            @Override            public void run() {                //这里写入子线程需要做的工作            Log.e("wanghe","asdasdasd");            Handler handler = new Handler(){                @Override                public void handleMessage(Message msg) {                    Toast.makeText(getApplicationContext(), "handler msg", Toast.LENGTH_LONG).show();                }            };            handler.sendEmptyMessage(1);        }    }).start();

运行之后，不出意外的报错

错误信息：
java.lang.RuntimeException: Can’t create handler inside thread that has not called Looper.prepare()
不能再子线程中新建handler，没有呼叫Looper.prepare();，为什么呢，看一下handler的源码

public Handler() {  if (FIND_POTENTIAL_LEAKS) {      final Class<? extends Handler> klass = getClass();      if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&              (klass.getModifiers() & Modifier.STATIC) == 0) {          Log.w(TAG, "The following Handler class should be static or leaks might occur: " +              klass.getCanonicalName());      }  }  mLooper = Looper.myLooper();  if (mLooper == null) {      throw new RuntimeException(          "Can't create handler inside thread that has not called Looper.prepare()");  }  mQueue = mLooper.mQueue;  mCallback = null;  }

handler构造函数中需要持有一个looper的对象，如果没有，提示这个错误；
looper的主要作用是与当前线程绑定，保证一个线程只会有一个Looper实例，同时一个Looper实例也只有一个MessageQueue。然后looper的loop()方法就是不断从MessageQueue中取出消息，交给handler去发送消息。而子线程是没有默认looper的，所以就会报错了。解决办法也很简单，我们只需要调用prepare()方法，新建looper对象就好。看一下prepare都干了什么：

Looper.prepare()

public static final void prepare() {      if (sThreadLocal.get() != null) {          throw new RuntimeException("Only one Looper may be created per thread");      }      sThreadLocal.set(new Looper(true));  }

可以看到方法中新建一个looper对象防放进了一个ThreadLocal的对象中，并且提前判断了ThreadLoacl是否为空，这就说明了prepare()不能被调用2次，也就保证了一个线程只能有一个looper;

private Looper(boolean quitAllowed) {      mQueue = new MessageQueue(quitAllowed);      mRun = true;      mThread = Thread.currentThread();  }

构造中新建了一个MessageQueue，现在，消息队列找到了，怎么从中这个队列中拿出消息给handler呢？调用Looper.loop；

Looper.loop()

public static void loop() {      final Looper me = myLooper();      if (me == null) {          throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");      }      final MessageQueue queue = me.mQueue;      // Make sure the identity of this thread is that of the local process,      // and keep track of what that identity token actually is.      Binder.clearCallingIdentity();      final long ident = Binder.clearCallingIdentity();      for (;;) {          Message msg = queue.next(); // might block          if (msg == null) {              // No message indicates that the message queue is quitting.              return;          }          // This must be in a local variable, in case a UI event sets the logger          Printer logging = me.mLogging;          if (logging != null) {              logging.println(">>>>> Dispatching to " + msg.target + " " +                      msg.callback + ": " + msg.what);          }          msg.target.dispatchMessage(msg);          if (logging != null) {              logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);          }          // Make sure that during the course of dispatching the          // identity of the thread wasn't corrupted.          final long newIdent = Binder.clearCallingIdentity();          if (ident != newIdent) {              Log.wtf(TAG, "Thread identity changed from 0x"                      + Long.toHexString(ident) + " to 0x"                      + Long.toHexString(newIdent) + " while dispatching to "                      + msg.target.getClass().getName() + " "                      + msg.callback + " what=" + msg.what);          }          msg.recycle();      }  }  public static Looper myLooper() {    return sThreadLocal.get();}

在myLooper中直接拿到了ThreadLoacl中存储的Looper实例，如果null就抛出，说明loop一定要在prepare之后调用；然后拿到了looper中的消息队列，进入无限循环，取消息->把消息嫁给msg的target的dispatchMessage方法处理，这个Msg的target是什么呢，就是我们很熟悉的Handler（饶了一圈终于找回来了。。。）
而在handler的源码中我们看到 handler通过持有的looper获取了looper的MessageQueue，这样就把Handler，looper ，message关联到了一起，

都走到这里了，就一口气看完handler处理message的逻辑吧

sendMessage()

public final boolean sendMessage(Message msg)   {       return sendMessageDelayed(msg, 0);   }   public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {       Message msg = Message.obtain();       msg.what = what;       return sendMessageDelayed(msg, delayMillis);   }   public final boolean sendMessageDelayed(Message msg, long delayMillis)     {     if (delayMillis < 0) {         delayMillis = 0;     }     return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);    }    public boolean sendMessageAtTime(Message msg, long uptimeMillis) {     MessageQueue queue = mQueue;     if (queue == null) {         RuntimeException e = new RuntimeException(                 this + " sendMessageAtTime() called with no mQueue");         Log.w("Looper", e.getMessage(), e);         return false;     }     return enqueueMessage(queue, msg, uptimeMillis);     }

最后调用到了endMessageAtTime，在此方法内部有直接获取MessageQueue然后调用了enqueueMessage方法，我们再来看看此方法：

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {     msg.target = this;     if (mAsynchronous) {         msg.setAsynchronous(true);     }     return queue.enqueueMessage(msg, uptimeMillis);     }

还记得上文looper.loop中会去除每个msg然后交给target.dispatchMessage(msg)去处理消息么？
enqueueMessage中首先为meg.target赋值为this，也就是把当前的handler作为msg的target属性。最终会调用queue的enqueueMessage的方法，也就是说handler发出的消息，最终会保存到消息队列中去。

现在已经很清楚了Looper会调用prepare()和loop()方法，在当前执行的线程中保存一个Looper实例，这个实例会保存一个MessageQueue对象，然后当前线程进入一个无限循环中去，不断从MessageQueue中读取Handler发来的消息。然后再回调创建这个消息的handler中的dispathMessage方法，下面我们赶快去看一看这个方法：

public void dispatchMessage(Message msg) {      if (msg.callback != null) {          handleCallback(msg);      } else {          if (mCallback != null) {              if (mCallback.handleMessage(msg)) {                  return;              }          }          handleMessage(msg);      }  }

这里最终调用了我们创建handler中复写的handlerMessage方法。
到此，整个流程基本理顺了一遍。
总结一下三者：

首先Looper.prepare()在本线程中保存一个Looper实例，然后该实例中保存一个MessageQueue对象；因为Looper.prepare()在一个线程中只能调用一次，所以MessageQueue在一个线程中只会存在一个。
Looper.loop()会让当前线程进入一个无限循环，不端从MessageQueue的实例中读取消息，然后回调msg.target.dispatchMessage(msg)方法。
Handler的构造方法，会首先得到当前线程中保存的Looper实例，进而与Looper实例中的MessageQueue想关联。
Handler的sendMessage方法，会给msg的target赋值为handler自身，然后加入MessageQueue中。
在构造Handler实例时，我们会重写handleMessage方法，也就是msg.target.dispatchMessage(msg)最终调用的方法。

总结完了，有人可能还会问，为什么UI线程中，并没有显示调用looper的prepare和loop方法，为什么就可以成功创建handler，因为在acitvity的启动代码中，就已经调用了looper的prepare和loop。
一句话总结：

Looper负责的就是创建一个MessageQueue，然后进入一个无限循环体不断从该MessageQueue中读取消息，而消息的创建者就是一个或多个Handler 。

后记

至此我们从一个常见的问题，引出来很多人都头疼的handler异步消息机制问题，查找了一些源码，希望对各位有帮助

转载注明出处：

文章出自我不只是看客的博客

常见面试题

Looper.prepare()

Looper.loop()

sendMessage()

Looper负责的就是创建一个MessageQueue，然后进入一个无限循环体不断从该MessageQueue中读取消息，而消息的创建者就是一个或多个Handler 。

后记

更多相关文章

随机推荐

子线程新建Handler为什么会报错？——浅谈Handler、Looper、Message关系

转载注明出处：

文章出自 我不只是看客的博客

常见面试题

Looper.prepare()

Looper.loop()

sendMessage()

Looper负责的就是创建一个MessageQueue，然后进入一个无限循环体不断从该MessageQueue中读取消息，而消息的创建者就是一个或多个Handler 。

后记

更多相关文章

随机推荐

文章出自我不只是看客的博客