Android开发笔记
11 分钟 读完 (大约 1591 个字)

Android的Handler消息机制分析

Handler的介绍中出现最多的关键字，Looper，ThreadLocal，MessageQueue。

在工作线程的 handler#sendMessage 方法实际上是向主线程即UI线程的消息队列插入消息，通过ActivityThread初始化Looper对象，并通过Looper.looper方法循环查询消息队列的新消息。

分析Handler消息机制我们先从 Handler#sendMessage() 方法来分析，先看一下sendMessage()方法最终会调用的方法，如下所示：

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

先大概看下这个方法的作用，就是向 MessageQueue 消息队列中插入一条消息。这里我们先不分析enqueueMessage() 方法，我们先来看一下 Handler 中的 MessageQueue 何时初始化的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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 " + Thread.currentThread()
      + " that has not called Looper.prepare()");
  }
  mQueue = mLooper.mQueue;
  mCallback = callback;
  mAsynchronous = async;
}

可以看到 mQueue 是在 Handler 的构造方法中初始化的，而 mQueue 来自于 Looper 对象，一步步分析，我们接着分析 Looper对象，即 mLooper = Looper.myLooper() 点击 myLooper() 方法我们可以看到：

1
2
3
4
5
6
7
/**
 * Return the Looper object associated with the current thread.  Returns
 * null if the calling thread is not associated with a Looper.
 */
public static @Nullable Looper myLooper() {
    return sThreadLocal.get();
}

到这里 Handler 中的三个关键点MessageQueue 、Looper 、ThreadLocal都出现了，现在我们要分析的 sThreadLocal.get() 从哪里获取 Looper 对象。先简单介绍一下ThreadLocal类：保存线程中的变量，仅当线程存活的时候才可以获取到该变量。现在要看一下哪里调用 ThreadLocal.set(Looper) 方法，如下所示：

1
2
3
4
5
6
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));
}

我们都知道Activity在创建过程中，ActivityThread 的main方法中会调用 Looper.prepareMainLooper() 方法，这里的执行过程中还有一个关键的方法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
47
48
49
50
public static void main(String[] args) {
  Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");

  // CloseGuard defaults to true and can be quite spammy.  We
  // disable it here, but selectively enable it later (via
  // StrictMode) on debug builds, but using DropBox, not logs.
  CloseGuard.setEnabled(false);

  Environment.initForCurrentUser();

  // Set the reporter for event logging in libcore
  EventLogger.setReporter(new EventLoggingReporter());

  // Make sure TrustedCertificateStore looks in the right place for CA certificates
  final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
  TrustedCertificateStore.setDefaultUserDirectory(configDir);

  Process.setArgV0("<pre-initialized>");

  Looper.prepareMainLooper();

  // Find the value for {@link #PROC_START_SEQ_IDENT} if provided on the command line.
  // It will be in the format "seq=114"
  long startSeq = 0;
  if (args != null) {
    for (int i = args.length - 1; i >= 0; --i) {
      if (args[i] != null && args[i].startsWith(PROC_START_SEQ_IDENT)) {
        startSeq = Long.parseLong(
          args[i].substring(PROC_START_SEQ_IDENT.length()));
      }
    }
  }
  ActivityThread thread = new ActivityThread();
  thread.attach(false, startSeq);

  if (sMainThreadHandler == null) {
    sMainThreadHandler = thread.getHandler();
  }

  if (false) {
    Looper.myLooper().setMessageLogging(new
                                        LogPrinter(Log.DEBUG, "ActivityThread"));
  }

  // End of event ActivityThreadMain.
  Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
  Looper.loop();

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

最终会调用上面提到的 prepare(boolean quitAllowed) 方法。到这里我们只把只把几个关键点何时创建介绍了一下。接下来介绍Handler传递消息的过程。还是接着 sendMessageAtTime(Message msg, long uptimeMillis)方法分析，注意这里的 msg.target 为Handler对象。上面讲到 sendMessage 会通过 enqueueMessage(queue, msg, uptimeMillis) 向我们的消息队列插入消息，Message为单向链表，根据消息处理时间来判断链表的添加顺序，该方法如下所示：

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
47
48
49
50
51
52
53
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) {
    if (mQuitting) {
      IllegalStateException e = new IllegalStateException(
        msg.target + " sending message to a Handler on a dead thread");
      Log.w(TAG, e.getMessage(), e);
      msg.recycle();
      return false;
    }

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

    // We can assume mPtr != 0 because mQuitting is false.
    if (needWake) {
      nativeWake(mPtr);
    }
  }
  return true;
}

最后通过 Looper#looper 循环从 MessageQueue 中取消息:

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
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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();

  // Allow overriding a threshold with a system prop. e.g.
  // adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'
  final int thresholdOverride =
    SystemProperties.getInt("log.looper."
                            + Process.myUid() + "."
                            + Thread.currentThread().getName()
                            + ".slow", 0);

  boolean slowDeliveryDetected = false;

  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
    final Printer logging = me.mLogging;
    if (logging != null) {
      logging.println(">>>>> Dispatching to " + msg.target + " " +
                      msg.callback + ": " + msg.what);
    }

    final long traceTag = me.mTraceTag;
    long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
    long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;
    if (thresholdOverride > 0) {
      slowDispatchThresholdMs = thresholdOverride;
      slowDeliveryThresholdMs = thresholdOverride;
    }
    final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0) && (msg.when > 0);
    final boolean logSlowDispatch = (slowDispatchThresholdMs > 0);

    final boolean needStartTime = logSlowDelivery || logSlowDispatch;
    final boolean needEndTime = logSlowDispatch;

    if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
      Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
    }

    final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;
    final long dispatchEnd;
    try {
      msg.target.dispatchMessage(msg);
      dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
    } finally {
      if (traceTag != 0) {
        Trace.traceEnd(traceTag);
      }
    }
    if (logSlowDelivery) {
      if (slowDeliveryDetected) {
        if ((dispatchStart - msg.when) <= 10) {
          Slog.w(TAG, "Drained");
          slowDeliveryDetected = false;
        }
      } else {
        if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, "delivery",
                        msg)) {
          // Once we write a slow delivery log, suppress until the queue drains.
          slowDeliveryDetected = true;
        }
      }
    }
    if (logSlowDispatch) {
      showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", 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.recycleUnchecked();
  }
}

msg.target.dispatchMessage(msg) 的处理方法最终是调用 Handler#dispatchMessage 方法，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
     * Handle system messages here.
     */
public void dispatchMessage(Message msg) {
  if (msg.callback != null) {
    handleCallback(msg);
  } else {
    if (mCallback != null) {
      if (mCallback.handleMessage(msg)) {
        return;
      }
    }
    handleMessage(msg);
  }
}

讲到这里我们不但看出最后是走到我们覆盖的 handleMessage(msg) 方法中，而且看到有个 msg.callback 判断，这个callback是什么？callback 为 Runable 的实例，这也就解释了为什么 Handler#post(Runable()) 方法最终是在UI线程中处理的。如果不理解的话，看一下Handler的post方法就知道了。

1
2
3
public final boolean post(Runnable r){
	return  sendMessageDelayed(getPostMessage(r), 0);
}
# Handler

喜欢这篇文章？打赏一下作者吧

Android中的IPC之Binder机制
Activity启动流程分析

最新文章

分类

归档

标签

AIO 1
Android 5
Android开发艺术探索 1
App Links 1
BIO 1
BroadcastReceiver 1
Error 1
Exception 1
Handler 1
List 1
Map 1
NIO 1
Rxjava操作符 4
Set 1
View 1
adjustPan 1
adjustResize 1
gradle 1
jdk 1
jre 1
jvm 1
throw 1
throws 1
内部类 1
启动模式 1
基本类型 1
堆栈 1
引用类型 1
抽象 1
接口 1
操作系统 1
混淆 1
特征 1
生命周期 1
线程 2
软键盘遮挡 1
进程 1
闭包 1

链接

Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×