Android消息处理机制

在Android里面更新UI经常用到Handler,但仅限于“基本会用”的状态,时不时就出现一些不解的Exception,虽然通过网络,博客,基本把问题都解决了,但是也下定决心去学习一下原理,下面是学习后自己的一些理解和记录。

首先在官方文档上,一个标准的异步消息处理线程是这样写的:

class LooperThread extends Thread {  
      public Handler mHandler;  
  
      public void run() {  
          Looper.prepare();  
  
          mHandler = new Handler() {  
              public void handleMessage(Message msg) {  
                  // process incoming messages here  
              }  
          };  
  
          Looper.loop();  
      }  
  }  

里面主要有Looper、Handler、Message,查了一下对这三者的描述:

Looper:建立和管理一个基于消息队列(MessageQueue)的事件循环;
Handler:发送和处理与线程的消息队列相关的消息和Runnable对象;
Message:定义一个可以被发送到Handler的包含描述和任意数据对象的消息。

这里看到有一个消息队列(MessageQueue),很容易理解,就是放置Message的队列集合。

就顺着这个标准写法的代码看下去,首先是Looper.prepare():

public static void prepare() {
        prepare(true);
    }

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

可以看到Looper.prepare()的实现是在第二个构造方法里面,查找代码可以发现:

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

sThreadLocal是一个静态的存储Looper类型数据的ThreadLocal对象,那么sThreadLocal.get() 返回的就是一个Looper对象。

所以Looper.prepare()的作用就是,每个线程只能有一个Looper对象,如果已经有Looper对象,报"Only one Looper may be created per thread"异常,如果没有,新建一个Looper对象放入ThreadLocal中。

再看Looper()的源码:

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

创建一个消息队列;绑定到当前线程中。

那么很容易得到下面的结论:
1.当前线程只能有一个Looper对象;
2.每个Looper管理一个MessageQueue。

Looper.prepare()的作用就是保证以上两点,Thread、Looper、MessageQueue就这样联系起来了。

然后接下来就是Handler,但在这之前,想想发现平时在Activity里面都是直接实现Handler的,并没有调用Looper.prepare()和Looper.loop()啊。
原因就是:Activity所在的线程是主UI线程,在Activity的源码里面,有一个ActivityThread,这就是Activity所在的线程,里面有这样一段代码:

public static void main(String[] args) {
        ...
        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        ...
        Looper.loop();

        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }

这两段代码很容易懂了,就是主线程里面其实已经调用了Looper.prepare()和Looper.loop()了,而且可以看到还是符合上面的结论的。

那么继续看Handler,照例是进去看一看源码:

public Handler() {
        this(null, false);
    }

public Handler(Callback callback, boolean async) {
       ...

        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 = callback;
        mAsynchronous = async;
    }

public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

首先当前线程一定要存在Looper对象,不然就报"Can't create handler inside thread that has not called Looper.prepare()"异常,然后mQueue = mLooper.mQueue这就将MessageQueue与Handler也联系起来了。

Handler的构造方法就做了这么简单一件事,而里面的回调方法:

public void handleMessage(Message msg) { }

用过的都知道这里面就是对发送来的Message的处理逻辑实现,所以先来看一下Message和发送Message是怎样的。

先看Message,从对Message的描述可以知道“包含描述和任意数据对象”,在Message的源码可以看到它有很多属性字段,主要有arg1、arg2、what、obj、replyTo等:
1.arg1和arg2是用来存放整型数据的;
2.what是用来保存消息标示的;
3.obj是Object类型的任意对象;
4.replyTo是消息管理器,会关联到一个handler,handler就是处理其中的消息。

而发送消息就有很多方法了:

public final boolean sendMessage(Message msg)  
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) 
public final boolean sendMessageDelayed(Message msg, long delayMillis) 
public boolean sendMessageAtTime(Message msg, long uptimeMillis)

而查看这些方法的源码可以发现最后都是

return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);

sendMessage()实际调用了sendMessageDelayed(),不过delayMillis为0而已。
那么看一下sendMessageAtTime(...):

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);
    }

如果消息队列里面有Message的话,调用enqueueMessage():

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

看第一行代码:

 msg.target = this;

因为这些方法都是Handler类里面的,所以这个this是Handler本身,将Handler对象赋给Message的target字段,然后最后调用的是:

 boolean enqueueMessage(Message msg, long when) {
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }
        if (msg.isInUse()) {
            throw new IllegalStateException(msg + " This message is already in use.");
        }

        synchronized (this) {
            ....
            msg.markInUse();
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {
                // New head, wake up the event queue if blocked.
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                // Inserted within the middle of the queue.  Usually we don't have to wake
                // up the event queue unless there is a barrier at the head of the queue
                // and the message is the earliest asynchronous message in the queue.
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;
                for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        needWake = false;
                    }
                }
                msg.next = p; // invariant: p == prev.next
                prev.next = msg;
            }

          ...
        }
        return true;
    }

代码很长!不过看逻辑和注释不难懂,按照message的when,消息标识,一个个根据时间的顺序调用msg.next,从而为每一个消息指定它的下一个消息是什么,这样就在没有队列集合的情况下相当于把消息“入队”了。

看到这里,知道了Message的构成,知道了sendMessage()等一堆发送Message的方法是将消息放入MessageQueue。

那么最后到底是怎么将Message和Handler关联起来,从而在Handler的handleMessage()里面处理Message呢?

看标准写法代码里面的最后一块,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;

        ...
        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

           ...

            msg.target.dispatchMessage(msg);

           ...
        }
    }

代码也很长,显示里面关键的代码:
1.首先从Looper对象里面获得MessageQueue;
2.在一个死循环里面从消息队列里面取出消息;
3.将消息交给msg.target的dispatchMessage(Message)处理。

msg.target!上面说过,在handler调用发送Message的方法的时候,其中有一步,就是将handler本身赋给Message的target!所以明白了,就是这一步,将Message和Handler对象关联起来。继续看dispatchMessage():

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

public void handleMessage(Message msg) {
    }

果然,Handler里面有dispatchMessage(),而dispatchMessage()里面就调用了handleMessage(),至于handleMessage的默认实现为空,很容易理解了,就是让我们去重写它,实现需要的消息处理逻辑。

绕了一大圈,把Looper的prepare()、loop(),Handler的handleMessage()、sendMessage(),Message等等都看了一遍源码,捋了一遍里面的逻辑,最后把这个消息处理机制的过程来个总结吧:
1.在一个线程里面,只有一个Looper对象,Looper对象被创建时,创建一个MessageQueue;
2.Handler在Looper之后创建,在构造时得到Looper实例,然后与Looper里面的MessageQueue关联起来;
3.Handler在发送Message的时候调用的sendMessageXXX(Message)中,将自身赋给Message的target字段,从而与Message关联起来,并将Message“入队”MessageQueue;
4.Handler重写handleMessage(),实现对Message的处理;
5.Looper的loop()不断循环从MessageQueue中取出Message,然后回调msg.target.dispatchMessage(),而msg.target就是Handler,dispatchMessage()最后调用的就是Handler的handleMessage()。

就到这里,如有错误欢迎指正,欢迎多多交流。

推荐阅读更多精彩内容