在Android中，经常使用Handler来实现线程间通信，必然要理解Looper , Handler , Message和MessageQueue的使用和原理，下面说一下Looper , Handler , Message有什么关系？下面从源码角度介绍3者关系，再给出一个结论。

1、导论

Handler 、 Looper 、Message 这三者都与Android异步消息处理线程相关的概念。

什么叫异步消息处理线程呢？

异步消息处理线程启动后会进入一个无限的循环体之中，每循环一次，从其内部的消息队列中取出一个消息，然后回调相应的消息处理函数，执行完成一个消息后则继续循环。若消息队列为空，线程则会阻塞等待。

那么和Handler 、 Looper 、Message有啥对应关系？

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

2、 源码分析

1、Looper

对于Looper主要是prepare()和loop()两个方法。
首先看prepare()方法
[java] view plain copy
  1. publicstaticfinalvoidprepare(){
  2. if(sThreadLocal.get()!=null){
  3. thrownewRuntimeException("OnlyoneLoopermaybecreatedperthread");
  4. }
  5. sThreadLocal.set(newLooper(true));
  6. }

sThreadLocal是一个ThreadLocal对象，可以在一个线程中存储变量。可以看到，在第5行，将一个Looper的实例放入了ThreadLocal，并且2-4行判断了sThreadLocal是否为null，否则抛出异常。这也就说明了Looper.prepare()方法不能被调用两次，同时也保证了一个线程中只有一个Looper实例


下面看Looper的构造方法：
[java] view plain copy
  1. privateLooper(booleanquitAllowed){
  2. mQueue=newMessageQueue(quitAllowed);
  3. mRun=true;
  4. mThread=Thread.currentThread();
  5. }
在构造方法中，创建了一个MessageQueue（消息队列）。
然后我们看loop()方法：
[java] view plain copy
  1. publicstaticvoidloop(){
  2. finalLooperme=myLooper();
  3. if(me==null){
  4. thrownewRuntimeException("NoLooper;Looper.prepare()wasn'tcalledonthisthread.");
  5. }
  6. finalMessageQueuequeue=me.mQueue;
  8. //Makesuretheidentityofthisthreadisthatofthelocalprocess,
  9. //andkeeptrackofwhatthatidentitytokenactuallyis.
  10. Binder.clearCallingIdentity();
  11. finallongident=Binder.clearCallingIdentity();
  13. for(;;){
  14. Messagemsg=queue.next();//mightblock
  15. if(msg==null){
  16. //Nomessageindicatesthatthemessagequeueisquitting.
  17. return;
  18. }
  20. //Thismustbeinalocalvariable,incaseaUIeventsetsthelogger
  21. Printerlogging=me.mLogging;
  22. if(logging!=null){
  23. logging.println(">>>>>Dispatchingto"+msg.target+""+
  24. msg.callback+":"+msg.what);
  25. }
  27. msg.target.dispatchMessage(msg);
  29. if(logging!=null){
  30. logging.println("<<<<<Finishedto"+msg.target+""+msg.callback);
  31. }
  33. //Makesurethatduringthecourseofdispatchingthe
  34. //identityofthethreadwasn'tcorrupted.
  35. finallongnewIdent=Binder.clearCallingIdentity();
  36. if(ident!=newIdent){
  37. Log.wtf(TAG,"Threadidentitychangedfrom0x"
  38. +Long.toHexString(ident)+"to0x"
  39. +Long.toHexString(newIdent)+"whiledispatchingto"
  40. +msg.target.getClass().getName()+""
  41. +msg.callback+"what="+msg.what);
  42. }
  44. msg.recycle();
  45. }
  46. }
代码的第2行：
public static Looper myLooper() {
return sThreadLocal.get();
}
方法直接返回了sThreadLocal存储的Looper实例，如果me为null则抛出异常，也就是说looper方法必须在prepare方法之后运行。
第6行：拿到该looper实例中的mQueue（消息队列）
13到45行：就进入了我们所说的无限循环。
14行：取出一条消息，如果没有消息则阻塞。
27行：使用调用 msg.target.dispatchMessage(msg);把消息交给msg的target的dispatchMessage方法去处理。Msg的target是什么呢？其实就是handler对象，下面会进行分析。
44行：释放消息占据的资源。

Looper主要作用：


1、 与当前线程绑定，保证一个线程只会有一个Looper实例，同时一个Looper实例也只有一个MessageQueue。
2、 loop()方法，不断从MessageQueue中去取消息，交给消息的target属性的dispatchMessage去处理。
好了，我们的异步消息处理线程已经有了消息队列（MessageQueue），也有了在无限循环体中取出消息的哥们，现在缺的就是发送消息的对象了，于是乎：Handler登场了。

2、Handler

使用Handler之前，我们都是初始化一个实例，比如用于更新UI线程，我们会在声明的时候直接初始化，或者在onCreate中初始化Handler实例。所以我们首先看Handler的构造方法，看其如何与MessageQueue联系上的，它在子线程中发送的消息（一般发送消息都在非UI线程）怎么发送到MessageQueue中的。
[java] view plain copy
  1. publicHandler(){
  2. this(null,false);
  3. }
  4. publicHandler(Callbackcallback,booleanasync){
  5. if(FIND_POTENTIAL_LEAKS){
  6. finalClass<?extendsHandler>klass=getClass();
  7. if((klass.isAnonymousClass()||klass.isMemberClass()||klass.isLocalClass())&&
  8. (klass.getModifiers()&Modifier.STATIC)==0){
  9. Log.w(TAG,"ThefollowingHandlerclassshouldbestaticorleaksmightoccur:"+
  10. klass.getCanonicalName());
  11. }
  12. }
  14. mLooper=Looper.myLooper();
  15. if(mLooper==null){
  16. thrownewRuntimeException(
  17. "Can'tcreatehandlerinsidethreadthathasnotcalledLooper.prepare()");
  18. }
  19. mQueue=mLooper.mQueue;
  20. mCallback=callback;
  21. mAsynchronous=async;
  22. }

14行：通过Looper.myLooper()获取了当前线程保存的Looper实例，然后在19行又获取了这个Looper实例中保存的MessageQueue（消息队列），这样就保证了handler的实例与我们Looper实例中MessageQueue关联上了。

然后看我们最常用的sendMessage方法

[java] view plain copy
  1. publicfinalbooleansendMessage(Messagemsg)
  2. {
  3. returnsendMessageDelayed(msg,0);
  4. }
[java] view plain copy
  1. publicfinalbooleansendEmptyMessageDelayed(intwhat,longdelayMillis){
  2. Messagemsg=Message.obtain();
  3. msg.what=what;
  4. returnsendMessageDelayed(msg,delayMillis);
  5. }
[java] view plain copy
  1. publicfinalbooleansendMessageDelayed(Messagemsg,longdelayMillis)
  2. {
  3. if(delayMillis<0){
  4. delayMillis=0;
  5. }
  6. returnsendMessageAtTime(msg,SystemClock.uptimeMillis()+delayMillis);
  7. }
[java] view plain copy
  1. publicbooleansendMessageAtTime(Messagemsg,longuptimeMillis){
  2. MessageQueuequeue=mQueue;
  3. if(queue==null){
  4. RuntimeExceptione=newRuntimeException(
  5. this+"sendMessageAtTime()calledwithnomQueue");
  6. Log.w("Looper",e.getMessage(),e);
  7. returnfalse;
  8. }
  9. returnenqueueMessage(queue,msg,uptimeMillis);
  10. }

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

[java] view plain copy
  1. privatebooleanenqueueMessage(MessageQueuequeue,Messagemsg,longuptimeMillis){
  2. msg.target=this;
  3. if(mAsynchronous){
  4. msg.setAsynchronous(true);
  5. }
  6. returnqueue.enqueueMessage(msg,uptimeMillis);
  7. }

enqueueMessage中首先为meg.target赋值为this，【如果大家还记得Looper的loop方法会取出每个msg然后交给msg,target.dispatchMessage(msg)去处理消息】，也就是把当前的handler作为msg的target属性。最终会调用queue的enqueueMessage的方法，也就是说handler发出的消息，最终会保存到消息队列中去。

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

[java] view plain copy
  1. publicvoiddispatchMessage(Messagemsg){
  2. if(msg.callback!=null){
  3. handleCallback(msg);
  4. }else{
  5. if(mCallback!=null){
  6. if(mCallback.handleMessage(msg)){
  7. return;
  8. }
  9. }
  10. handleMessage(msg);
  11. }
  12. }
可以看到，第10行，调用了handleMessage方法，下面我们去看这个方法：

[java] view plain copy
  1. /**
  2. *Subclassesmustimplementthistoreceivemessages.
  3. */
  4. publicvoidhandleMessage(Messagemsg){
  5. }
可以看到这是一个空方法，为什么呢，因为消息的最终回调是由我们控制的，我们在创建handler的时候都是复写handleMessage方法，然后根据msg.what进行消息处理。

例如：

[java] view plain copy
  1. privateHandlermHandler=newHandler()
  2. {
  3. publicvoidhandleMessage(android.os.Messagemsg)
  4. {
  5. switch(msg.what)
  6. {
  7. casevalue:
  9. break;
  11. default:
  12. break;
  13. }
  14. };
  15. };

到此，这个流程已经解释完毕，让我们首先总结一下

1、首先Looper.prepare()在本线程中保存一个Looper实例，然后该实例中保存一个MessageQueue对象；因为Looper.prepare()在一个线程中只能调用一次，所以MessageQueue在一个线程中只会存在一个。

2、Looper.loop()会让当前线程进入一个无限循环，不端从MessageQueue的实例中读取消息，然后回调msg.target.dispatchMessage(msg)方法。

3、Handler的构造方法，会首先得到当前线程中保存的Looper实例，进而与Looper实例中的MessageQueue想关联。

4、Handler的sendMessage方法，会给msg的target赋值为handler自身，然后加入MessageQueue中。

5、在构造Handler实例时，我们会重写handleMessage方法，也就是msg.target.dispatchMessage(msg)最终调用的方法。

好了，总结完成，大家可能还会问，那么在Activity中，我们并没有显示的调用Looper.prepare()和Looper.loop()方法，为啥Handler可以成功创建呢，这是因为在Activity的启动代码中，已经在当前UI线程调用了Looper.prepare()和Looper.loop()方法。


3、Handler 的post方法

下面说一下Handler的post方法创建的线程和UI线程有什么关系？这里需要说明，有时候为了方便，我们会直接写如下代码：

[java] view plain copy
  1. mHandler.post(newRunnable()
  2. {
  3. @Override
  4. publicvoidrun()
  5. {
  6. Log.e("TAG",Thread.currentThread().getName());
  7. mTxt.setText("yoxi");
  8. }
  9. });
然后run方法中可以写更新UI的代码，其实这个Runnable并没有创建什么线程，要创建线程要通过new Thread执行run方法，然后再调用start()方法开启线程或者实现Runnable接口。而post方法的代码段中，只是new了Runnable对象，执行了run方法，相当于执行了一个普通的代码段。另外，看源码是发送了一条消息。

[java] view plain copy
  1. publicfinalbooleanpost(Runnabler)
  2. {
  3. returnsendMessageDelayed(getPostMessage(r),0);
  4. }
[java] view plain copy
  1. privatestaticMessagegetPostMessage(Runnabler){
  2. Messagem=Message.obtain();
  3. m.callback=r;
  4. returnm;
  5. }

可以看到，在getPostMessage中，得到了一个Message对象，然后将我们创建的Runable对象作为callback属性，赋值给了此message.

注：产生一个Message对象，可以new ，也可以使用Message.obtain()方法；两者都可以，但是更建议使用obtain方法，因为Message内部维护了一个Message池用于Message的复用，避免使用new 重新分配内存。

[java] view plain copy
  1. publicfinalbooleansendMessageDelayed(Messagemsg,longdelayMillis)
  2. {
  3. if(delayMillis<0){
  4. delayMillis=0;
  5. }
  6. returnsendMessageAtTime(msg,SystemClock.uptimeMillis()+delayMillis);
  7. }
[java] view plain copy
  1. publicbooleansendMessageAtTime(Messagemsg,longuptimeMillis){
  2. MessageQueuequeue=mQueue;
  3. if(queue==null){
  4. RuntimeExceptione=newRuntimeException(
  5. this+"sendMessageAtTime()calledwithnomQueue");
  6. Log.w("Looper",e.getMessage(),e);
  7. returnfalse;
  8. }
  9. returnenqueueMessage(queue,msg,uptimeMillis);
  10. }
最终和handler的sendMessage一样，调用了sendMessageAtTime，然后调用了enqueueMessage方法，给msg.target赋值为handler，最终加入MessagQueue.

可以看到，这里msg的callback和target都有值，那么会执行哪个呢？

其实上面已经贴过代码，就是dispatchMessage方法：

[java] view plain copy
  1. publicvoiddispatchMessage(Messagemsg){
  2. if(msg.callback!=null){
  3. handleCallback(msg);
  4. }else{
  5. if(mCallback!=null){
  6. if(mCallback.handleMessage(msg)){
  7. return;
  8. }
  9. }
  10. handleMessage(msg);
  11. }
  12. }
第2行，如果不为null，则执行callback回调，也就是我们的Runnable对象。

通过以上的介绍，关于Looper , Handler , Message 这三者关系上面已经叙述的非常清楚了。下面通过一张图来了解一下流程：

Android线程间通信机制——深入理解 Looper、Handler、Message_第1张图片

希望图片可以更好的帮助大家的记忆~~

4、补充

其实Handler不仅可以更新UI，你完全可以在一个子线程中Thread线程，去创建一个Handler，然后，使用这个handler实例在任何其他线程中发送消息，最终处理消息的代码都会在你创建Handler实例的线程中运行。

[java] view plain copy
  1. newThread()
  2. {
  3. privateHandlerhandler;
  4. publicvoidrun()
  5. {
  7. Looper.prepare();
  9. handler=newHandler()
  10. {
  11. publicvoidhandleMessage(android.os.Messagemsg)
  12. {
  13. Log.e("TAG",Thread.currentThread().getName());
  14. };
  15. };
  16. Looper.loop();
  17. }

最后，Android框架的设计思想有很多方面是值得我们借鉴的，不仅给我们提供了异步消息处理机制来更好的实现UI的更新，实现子线程与主线程交互，或者子线程与子线程之间进行通信。我们在开发中，一定要深入理解各种机制的原理，还可以把源码的编程思想应用到平时得Android项目开发中。



更多相关文章

  1. Android文件系统的提取方法（一）
  2. Android进程与线程的概念
  3. Android世界：android 线程池
  4. Android获取webView快照与屏幕截屏的方法
  5. Android测量View宽和高的一般通用方法
  6. 实用Android studio gradle的离线安装方法（官方）

随机推荐

  1. CTS bug排除
  2. 解决scrollview嵌套ImageView时，出现除顶
  3. Android封装SDK的使用
  4. 模拟器上安装Android(安卓)Market
  5. android是什么意思
  6. Android开发者必知的开发资源
  7. Android中MVC的具体体现
  8. android style(样式)和theme(主题)设置
  9. Android(安卓)的表格控件GridView学习
  10. Android框架学习-5.设置（Settings）