android的消息处理机制

    |     2015年12月23日   |   Android UI界面   |     0 条评论   |    1460

android的消息处理有三个核心类:Looper,Handler和Message。其实还有一个Message Queue(消息队列),但是MQ被封装到Looper里面了,我们不会直接与MQ打交道,因此我没将其作为核心类。下面一一介绍:

线程的魔法师 Looper

Looper的字面意思是“循环者”,它被设计用来使一个普通线程变成Looper线程。所谓Looper线程就是循环工作的线程。在程序开发中(尤其是GUI开发中),我们经常会需要一个线程不断循环,一旦有新任务则执行,执行完继续等待下一个任务,这就是Looper线程。使用Looper类创建Looper线程很简单:

  1. public class LooperThread extends Thread {  
  2.   
  3. @Override  
  4. public void run() {  
  5.         // 将当前线程初始化为Looper线程   
  6.         Looper.prepare();  
  7.         // …其他处理,如实例化handler   
  8.         // 开始循环处理消息队列   
  9.         Looper.loop();  
  10.     }  
  11. }  

通过上面两行核心代码,你的线程就升级为Looper线程了!!!是不是很神奇?让我们放慢镜头,看看这两行代码各自做了什么。
1)Looper.prepare()

通过上图可以看到,现在你的线程中有一个Looper对象,它的内部维护了一个消息队列MQ。注意,一个Thread只能有一个Looper对象,为什么呢?咱们来看源码。

    1. public class Looper {  
    2.     // 每个线程中的Looper对象其实是一个ThreadLocal,即线程本地存储(TLS)对象   
    3.     private static final ThreadLocal sThreadLocal = new ThreadLocal();  
    4.   
    5.     // Looper内的消息队列   
    6.     final MessageQueue mQueue;  
    7.   
    8.     // 当前线程   
    9.     Thread mThread;  
    10.   
    11.     // 。。。其他属性   
    12.   
    13.     // 每个Looper对象中有它的消息队列,和它所属的线程   
    14.     private Looper() {  
    15.         mQueue = new MessageQueue();  
    16.         mRun = true;  
    17.         mThread = Thread.currentThread();  
    18.     }  
    19.   
    20.     // 我们调用该方法会在调用线程的TLS中创建Looper对象   
    21.     public static final void prepare() {  
    22.         if (sThreadLocal.get() != null) {  
    23.             // 试图在有Looper的线程中再次创建Looper将抛出异常   
    24.             throw new RuntimeException(“Only one Looper may be created per thread”);  
    25.         }  
    26.         sThreadLocal.set(new Looper());  
    27.     }  
    28.     // 其他方法   
    29. }

通过源码,prepare()背后的工作方式一目了然,其核心就是将looper对象定义为ThreadLocal。如果你还不清楚什么是ThreadLocal,请参考《理解ThreadLocal》
2)Looper.loop()

调用loop方法后,Looper线程就开始真正工作了,它不断从自己的MQ中取出队头的消息(也叫任务)执行。其源码分析如下:

  1. public static final void loop() {  
  2.         Looper me = myLooper();  //得到当前线程Looper   
  3.         MessageQueue queue = me.mQueue;  //得到当前looper的MQ   
  4.         // 这两行没看懂= = 不过不影响理解   
  5.         Binder.clearCallingIdentity();  
  6.   
  7.         final long ident = Binder.clearCallingIdentity();  
  8.   
  9.         // 开始循环   
  10.         while (true) {  
  11.             Message msg = queue.next(); // 取出message   
  12.             if (msg != null) {  
  13.                 if (msg.target == null) {  
  14.                     // message没有target为结束信号,退出循环   
  15.                     return;  
  16.                 }  
  17.                 // 日志。。。   
  18.                 if (me.mLogging!= null) me.mLogging.println(  
  19.                         “>>>>> Dispatching to “ + msg.target + ” “  
  20.                         + msg.callback + “: “ + msg.what  
  21.                         );  
  22.                 // 非常重要!将真正的处理工作交给message的target,即后面要讲的handler   
  23.                 msg.target.dispatchMessage(msg);  
  24.                 // 还是日志。。。   
  25.                 if (me.mLogging!= null) me.mLogging.println(  
  26.                         “<<<<< Finished to    “ + msg.target + ” “  
  27.                         + msg.callback);  
  28.                                 // 下面没看懂,同样不影响理解   
  29.                 final long newIdent = Binder.clearCallingIdentity();  
  30.                 if (ident != newIdent) {  
  31.                     Log.wtf(“Looper”, “Thread identity changed from 0x”  
  32.                             + Long.toHexString(ident) + ” to 0x”  
  33.                             + Long.toHexString(newIdent) + ” while dispatching to “  
  34.                             + msg.target.getClass().getName() + ” “+ msg.callback + ” what=” + msg.what);  
  35.                 }  
  36.                 // 回收message资源   
  37.                 msg.recycle();  
  38.             }  
  39.         }  
  40.     } 

除了prepare()和loop()方法,Looper类还提供了一些有用的方法,比如
Looper.myLooper()得到当前线程looper对象:

  1. public static final Looper myLooper() {  
  2.         // 在任意线程调用Looper.myLooper()返回的都是那个线程的looper   
  3.         return (Looper)sThreadLocal.get();  
  4. }  

getThread()得到looper对象所属线程:

  1. public Thread getThread() {  
  2.         return mThread;  
  3. }  

quit()方法结束looper循环:

除了prepare()和loop()方法,Looper类还提供了一些有用的方法,比如
Looper.myLooper()得到当前线程looper对象:

  1. public static final Looper myLooper() {  
  2.         // 在任意线程调用Looper.myLooper()返回的都是那个线程的looper   
  3.         return (Looper)sThreadLocal.get();  
  4. }  

getThread()得到looper对象所属线程:

  1. public Thread getThread() {  
  2.         return mThread;  
  3. }  

quit()方法结束looper循环:

  1. public void quit() {  
  2.         // 创建一个空的message,它的target为NULL,表示结束循环消息   
  3.         Message msg = Message.obtain();  
  4.         // 发出消息   
  5.         mQueue.enqueueMessage(msg, 0);  
  6. }  

到此为止,你应该对Looper有了基本的了解,总结几点:
1.每个线程有且最多只能有一个Looper对象,它是一个ThreadLocal
2.Looper内部有一个消息队列,loop()方法调用后线程开始不断从队列中取出消息执行
3.Looper使一个线程变成Looper线程。
那么,我们如何往MQ上添加消息呢?下面有请Handler!

异步处理大师 Handler

什么是handler?handler扮演了往MQ上添加消息和处理消息的角色(只处理由自己发出的消息),即通知MQ它要执行一个任务(sendMessage),并在loop到自己的时候执行该任务(handleMessage),整个过程是异步的。handler创建时会关联一个looper,默认的构造方法将关联当前线程的looper,不过这也是可以set的。默认的构造方法:

    1. public class handler {  
    2.     final MessageQueue mQueue;  // 关联的MQ   
    3.   
    4.     final Looper mLooper;  // 关联的looper   
    5.   
    6.     final Callback mCallback;  
    7.   
    8.     // 其他属性   
    9.   
    10.     public Handler() {  
    11.         // 没看懂,直接略过,,,   
    12.         if (FIND_POTENTIAL_LEAKS) {  
    13.             final Class<? extends Handler> klass = getClass();  
    14.             if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&  
    15.                     (klass.getModifiers() & Modifier.STATIC) == 0) {  
    16.                 Log.w(TAG, “The following Handler class should be static or leaks might occur: “ +  
    17.                     klass.getCanonicalName());  
    18.             }  
    19.         }  
    20.         // 默认将关联当前线程的looper   
    21.         mLooper = Looper.myLooper();  
    22.         // looper不能为空,即该默认的构造方法只能在looper线程中使用   
    23.         if (mLooper == null) {  
    24.             throw new RuntimeException(  
    25.                 “Can’t create handler inside thread that has not called Looper.prepare()”);  
    26.         }  
    27.         // 重要!!!直接把关联looper的MQ作为自己的MQ,因此它的消息将发送到关联looper的MQ上   
    28.         mQueue = mLooper.mQueue;  
    29.         mCallback = null;  
    30.     }  
    31.     // 其他方法   
    32. }

下面我们就可以为之前的LooperThread类加入Handler:

    1. public class LooperThread extends Thread {  
    2.     private Handler handler1;  
    3.   
    4.     private Handler handler2;  
    5.   
    6.     @Override  
    7.     public void run() {  
    8.         // 将当前线程初始化为Looper线程   
    9.         Looper.prepare();  
    10.         // 实例化两个handler   
    11.         handler1 = new Handler();  
    12.         handler2 = new Handler();  
    13.         // 开始循环处理消息队列   
    14.         Looper.loop();  
    15.     }  
    16. }

加入handler后的效果如下图:

可以看到,一个线程可以有多个Handler,但是只能有一个Looper!
Handler发送消息

有了handler之后,我们就可以使用 post(Runnable),postAtTime(Runnable, long),postDelayed(Runnable, long),sendEmptyMessage(int),sendMessage(Message),sendMessageAtTime(Message, long)sendMessageDelayed(Message, long)这些方法向MQ上发送消息了。光看这些API你可能会觉得handler能发两种消息,一种是Runnable对象,一种是message对象,这是直观的理解,但其实post发出的Runnable对象最后都被封装成message对象了,见源码:

  1. public final boolean post(Runnable r)  
  2. {  
  3.     // 注意getPostMessage(r)将runnable封装成message   
  4.     return  sendMessageDelayed(getPostMessage(r), 0);  
  5. }  
  6.   
  7. private final Message getPostMessage(Runnable r) {  
  8.   
  9.      Message m = Message.obtain();  //得到空的message   
  10.      m.callback = r;  //将runnable设为message的callback   
  11.      return m;  
  12. }  
  13.   
  14. public boolean sendMessageAtTime(Message msg, long uptimeMillis)  
  15. {  
  16.      boolean sent = false;  
  17.      MessageQueue queue = mQueue;  
  18.      if (queue != null) {  
  19.          msg.target = this;  // message的target必须设为该handler!   
  20.          sent = queue.enqueueMessage(msg, uptimeMillis);  
  21.      }  
  22.      else {  
  23.          RuntimeException e = new RuntimeException(  
  24.              this + ” sendMessageAtTime() called with no mQueue”);  
  25.          Log.w(“Looper”, e.getMessage(), e);  
  26.       }  
  27.       return sent;  
  28. }

其他方法就不罗列了,总之通过handler发出的message有如下特点:
1.message.target为该handler对象,这确保了looper执行到该message时能找到处理它的handler,即loop()方法中的关键代码
msg.target.dispatchMessage(msg);
2.post发出的message,其callback为Runnable对象
Handler处理消息
说完了消息的发送,再来看下handler如何处理消息。消息的处理是通过核心方法dispatchMessage(Message msg)与钩子方法handleMessage(Message msg)完成的,见源码

  1. // 处理消息,该方法由looper调用   
  2. public void dispatchMessage(Message msg) {  
  3.     if (msg.callback != null) {  
  4.         // 如果message设置了callback,即runnable消息,处理callback!   
  5.         handleCallback(msg);  
  6.     } else {  
  7.         // 如果handler本身设置了callback,则执行callback   
  8.         if (mCallback != null) {  
  9.              /* 这种方法允许让activity等来实现Handler.Callback接口,避免了自己编写handler重写handleMessage方法。见http://alex-yang-xiansoftware-com.iteye.com/blog/850865 */  
  10.             if (mCallback.handleMessage(msg)) {  
  11.                 return;  
  12.             }  
  13.         }  
  14.         // 如果message没有callback,则调用handler的钩子方法handleMessage   
  15.         handleMessage(msg);  
  16.     }  
  17. }  
  18.   
  19.     // 处理runnable消息   
  20. private final void handleCallback(Message message) {  
  21.     message.callback.run();  //直接调用run方法!   
  22. }  
  23.   
  24. // 由子类实现的钩子方法   
  25. public void handleMessage(Message msg) {  
  26. }  

可以看到,除了handleMessage(Message msg)和Runnable对象的run方法由开发者实现外(实现具体逻辑),handler的内部工作机制对开发者是透明的。这正是handler API设计的精妙之处!
Handler的用处
我在小标题中将handler描述为“异步处理大师”,这归功于Handler拥有下面两个重要的特点:
1.handler可以在任意线程发送消息,这些消息会被添加到关联的MQ上。
              
2.handler是在它关联的looper线程中处理消息的。

这就解决了android最经典的不能在其他非主线程中更新UI的问题。android的主线程也是一个looper线程(looper在android中运用很广),我们在其中创建的handler默认将关联主线程MQ。因此,利用handler的一个solution就是在activity中创建handler并将其引用传递给worker thread,worker thread执行完任务后使用handler发送消息通知activity更新UI。(过程如图)

当然,handler能做的远远不仅如此,由于它能post Runnable对象,它还能与Looper配合实现经典的Pipeline Thread(流水线线程)模式。请参考此文《Android Guts: Intro to Loopers and Handlers》

封装任务 Message

在整个消息处理机制中,message又叫task,封装了任务携带的信息和处理该任务的handler。message的用法比较简单,这里不做总结了。但是有这么几点需要注意(待补充):
1.尽管Message有public的默认构造方法,但是你应该通过Message.obtain()来从消息池中获得空消息对象,以节省资源。
2.如果你的message只需要携带简单的int信息,请优先使用Message.arg1和Message.arg2来传递信息,这比用Bundle更省内存
3.擅用message.what来标识信息,以便用不同方式处理message。

其它理解

 

 

Message Queue
     在单线程模型下,为了解决类似的问题,Android设计了一个Message Queue(消息队列), 线程间可以通过该Message Queue并结合HandlerLooper组件进行信息交换。下面将对它们进行分别介绍:
    1. Message
    Message消息,理解为线程间交流的信息,处理数据后台线程需要更新UI,则发送Message内含一些数据给UI线程。

    2. Handler
    Handler处理者,是Message的主要处理者,负责Message的发送,Message内容的执行处理。后台线程就是通过传进来的Handler对象引用来sendMessage(Message)。而使用Handler,需要implement 该类的 handleMessage(Message)方法,它是处理这些Message的操作内容,例如Update UI。通常需要子类化Handler来实现handleMessage方法。

    3. Message Queue
    Message Queue消息队列,用来存放通过Handler发布的消息,按照先进先出执行。
    每个message queue都会有一个对应的HandlerHandler会向message queue通过两种方法发送消息:sendMessagepost。这两种消息都会插在message queue队尾并按先进先出执行。但通过这两种方法发送的消息执行的方式略有不同:通过sendMessage发送的是一个message对象,会被HandlerhandleMessage()函数处理;而通过post方法发送的是一个runnable对象,则会自己执行。

    4. Looper
    Looper是每条线程里的Message Queue的管家。Android没有GlobalMessage Queue,而Android会自动替主线程(UI线程)建立Message Queue,但在子线程里并没有建立Message Queue。所以调用Looper.getMainLooper()得到的主线程的Looper不为NULL,但调用Looper.myLooper()得到当前线程的Looper就有可能为NULL
    对于子线程使用LooperAPI Doc提供了正确的使用方法:
class LooperThread extends Thread {
    public Handler mHandler;

    public void run() {
        Looper.prepare(); //创建本线程的Looper并创建一个MessageQueue

        mHandler = new Handler() {
            public void handleMessage(Message msg) {
                // process incoming messages here
            }
        };
  
        Looper.loop(); //开始运行Looper,监听Message Queue
    }
}

    这个Message机制的大概流程:
    1. Looper.loop()方法运行开始后,循环地按照接收顺序取出Message Queue里面的非NULLMessage
    2. 一开始Message Queue里面的Message都是NULL的。当Handler.sendMessage(Message)Message Queue,该函数里面设置了那个Message对象的target属性是当前的Handler对象。随后Looper取出了那个Message,则调用该Messagetarget指向的HanderdispatchMessage函数对Message进行处理。
    在dispatchMessage方法里,如何处理Message则由用户指定,三个判断,优先级从高到低:
    1) Message里面的Callback,一个实现了Runnable接口的对象,其中run函数做处理工作;
    2) Handler里面的mCallback指向的一个实现了Callback接口的对象,由其handleMessage进行处理;
    3) 处理消息Handler对象对应的类继承并实现了其中handleMessage函数,通过这个实现的handleMessage函数处理消息。
    由此可见,我们实现的handleMessage方法是优先级最低的!
    3. Handler处理完该Message (update UI) 后,Looper则设置该MessageNULL,以便回收!

 

原文出处:android的消息处理机制(图+源码分析)——Looper,Handler,Message

转载请注明来源:android的消息处理机制
回复 取消