handler

发表于 | 次

1 handler

handler是Android给我们提供的一套更新UI的机制，也是一套消息处理机制。Android UI是线程不安全的，如果在子线程中尝试进行UI操作，程序就有可能会崩溃。通过创建一个Message对象，通过Handler发送出去，之后在Handler的handleMessage()方法中获得刚才发送的Message对象，然后在这里进行UI操作就不会再出现崩溃了。

在下面介绍handler机制前，首先得了解以下几个概念：

  • Message，为线程间通讯的数据单元。例如后台线程在处理数据完毕后需要更新UI，则可发送一条包含更新信息的Message给UI线程。
  • Message Queue，用来存放通过Handler发布的消息，按照先进先出(FIFO)执行。
  • Handler是Message的主要处理者，在构建handler时候内部会跟Looper进行关联，通过Looper.myLooper()获取到Looper，找到Looper也就找到了MessageQueue。在handler中发送消息，其实就是向MessageQueue队列中发送消息。
  • Looper，扮演Message Queue和Handler之间桥梁的角色，每一个Looper内部都包含一个MessageQueue。Looper.loop()负责循环取出Message Queue里面的Message.然后Looper交付给相应的Handler进行处理。
  • UI thread 通常就是main thread，每一个线程里可含有一个Looper对象以及一个MessageQueue数据结构。

Android官方给出的一个最标准的异步消息处理线程的写法应该是这样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class LooperThread extends Thread {  
      public Handler mHandler;  
  
      public void run() {  
          Looper.prepare();  // step 1
          mHandler = new Handler() {  // step 2
              public void handleMessage(Message msg) {  // step 3
                  // process incoming messages here  
              }  
          };  
          Looper.loop();  // step 4
      }  
  }
  • step1:Looper.prepare()方法的源码如下：
1
2
3
4
5
6
7
8
9
10
   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));
   }

可以看到，首先判断sThreadLocal中是否已经存在Looper了，如果还没有则创建一个新的Looper设置进去。Looper对象的构造函数源码如下：

1
2
3
4
5
private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);
    mRun = true;
    mThread = Thread.currentThread();
}

从源码中可以看出，每一个Looper对象都关联着一个MessageQueue 对象，MessageQueue对象主要管理Handler发送来的消息。
以上可以看出每个线程中最多只会有一个Looper对象和一个MessageQueue对象。

  • step2: Handler的构造方法如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public Handler(Callback callback, boolean async) {
        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 = callback;
        mAsynchronous = async;
    }

从上面的源码可知在构造handler对象的时候，其内部会关联一个Looper对象。

  • step3 handleMessage方法主要处理MessageQueue中Message。调用sendMessage方法最后都会辗转到对sendMessageAtTime的调用，其源码如下：
1
2
3
4
5
6
7
8
9
10
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);
    }

在sendMessageAtTime主要是将msg信息enqueue进队列中。

  • step 4 Looper.loop()源码如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
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();
    }
}

可以看到，这个方法会进入了一个死循环，然后不断地调用的MessageQueue的next()方法。如果当前MessageQueue中存在mMessages(即待处理消息)，就将这个消息出队，然后让下一条消息成为mMessages，否则就进入一个阻塞状态，一直等到有新的消息入队。loop方法会调用 msg.target.dispatchMessage(msg)。看一下dispatchMessage方法的源码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public void dispatchMessage(Message msg) {
     if (msg.callback != null) {// Message中callback 是一个Runnable对象
         handleCallback(msg);
     } else {
         if (mCallback != null) {
             if (mCallback.handleMessage(msg)) {
                 return;
             }
         }
         handleMessage(msg);
     }
 }
 ps：
 private static void handleCallback(Message message) {
     message.callback.run();
 } // 如果msg为一个Runnable对象，则会直接调用Runnable的Run方法

如果mCallback不为空，则调用mCallback的handleMessage()方法，否则直接调用Handler的handleMessage()方法，并将消息对象作为参数传递过去。

小结：Handler负责发送和处理Message，MessageQueue负责管理Message。Looper负责监视MessageQueue状态并从Queue中取出Message交由Handler来处理它。