剑客
关注科技互联网

Handler、Looper与MessageQueue源码分析

Android 中可以通过 Handler 来更新主线程中 UI 的变化,更新 UI 只能在主线程中进行更新,而为了让其他线程也能控制 UI 的变化, Android 提供了一种机制 HandlerLooperMessageQueue 一同协作来达到其他线程更新 UI 的目的。

一般我们会在主线程中通过如下方法定义一个 Handler

private Handler mHandler = new Handler() {
 @Override
 public void handleMessage(Message msg) {
 tv.setText("mHandler change UI");
 super.handleMessage(msg);
 }
 };

一般都见不到 LooperMessageQueue 的,那么它们都是在哪里调用与如何协作的呢?在主线程不会显式的调用 Looper 而是会在 ActivityThread.main 方法中默认调用。

ActivityThread.main

public static void main(String[] args) {
 Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
 SamplingProfilerIntegration.start();

 // 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();//创建Looper

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

 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();//开启Looper循环

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

如上代码,调用了 Looper.prepareMainLooper() 方法,在主线程中创建了一个 Looper ,不信的话我们再查看该方法做了什么

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并赋给sThreadLocal
 }

 /**
 * Initialize the current thread as a looper, marking it as an
 * application's main looper. The main looper for your application
 * is created by the Android environment, so you should never need
 * to call this function yourself. See also: {@link #prepare()}
 */
 public static void prepareMainLooper() {
 prepare(false);
 synchronized (Looper.class) {
 if (sMainLooper != null) {
 throw new IllegalStateException("The main Looper has already been prepared.");
 }
 sMainLooper = myLooper();
 }
 }

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

prepareMainLooper 方法中调用了 prepare 而通过 prepare 会发现它其实就是创建了一个 Looper ,并把它赋给了 sThreadLocal 。同时可以通过 myLooper 方法获取当前线程中的 Looper 。再来看下 new Looper(quitAllowed) 初始化了什么

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

在这里我们终于看到了 MessageQueue 了,它创建了一个 MessageQueue 。该消息队列就是用来保存后续的 Message 。再回到 ActivityThread.main 方法中,发现它调用了 Looper.loop() 是用来开启 Looper 循环的,监听消息队列 MessageQueue 中的消息。

loop

我们来看下 Looper.loop() 的源码:

public static void loop() {
 final Looper me = myLooper();//获取Looper
 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
 final Printer logging = me.mLogging;
 if (logging != null) {
 logging.println(">>>>> Dispatching to " + msg.target + " " +
 msg.callback + ": " + msg.what);
 }

 final long traceTag = me.mTraceTag;
 if (traceTag != 0) {
 Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
 }
 try {
 msg.target.dispatchMessage(msg);//通过Handler分发消息
 } finally {
 if (traceTag != 0) {
 Trace.traceEnd(traceTag);
 }
 }

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

loop 中首先获取了当前所在线程的 Looper ,同时也获取到了 Looper 中的 MessageQueue ,说明 Looper 已经与当前的线程进行了绑定。在后面开启了一个 for 的死循环,发现它做的事件是不断的从消息队列中取出消息,最后都交给 msg.target 调用它的 dispatchMessage 方法,那么 target 又是什么呢?我们进入 Message

Message

/*package*/ int flags;

 /*package*/ long when;

 /*package*/ Bundle data;

 /*package*/ Handler target;

 /*package*/ Runnable callback;

 // sometimes we store linked lists of these things
 /*package*/ Message next;

发现它就是我们熟悉的 Handler ,说明最后调用的就是 Handler 中的 dispatchMessage 方法,对消息的分发处理。这样一来 Handler 就通过 Looper 联系上了 Looper 所绑定的线程,即为主线程。

Handler

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 ,同时也获取了 Looper 中的消息队列。当然如果所处线程的 Looper 为空的话就会抛出异常,这就解释了为什么在非主线程中创建 Handler 要分别调用 Looper.prepareLooper.loop 而主线程则不需要,因为它默认已经调用了。

dispatchMessage

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

回到前面,对于 dispatchMessage 的处理,首先判断 msg.callback 是否为空,这里 callback 通过上面的 Message 应该能知道他就是一个 Runnable ,如果不为空则直接调用 Runnablerun 方法。否则调用 HandlerhandleMessage 方法.而这个方法相信大家已经很熟悉了,对事件的处理都是在这个方法中执行的。因为通过前面我们已经知道了 Handler 已经联系上了主线程,所以 handleMessage 中的处理自然相对于在主线程中进行,自然也能更新 UI 了。通过这里我们能把 Looper 比作是一个桥梁,来连接 Looper 所在的线程与 Handler 之间的通信,同时管理消息队列 MessageQueue 中的消息。那么前面的 Runnable 又是如何不为空的呢?我们使用 Handler 有两种方法,一种是直接创建一个 Handler 并且重写它的 handleMessage 方法,而另一种可以通过 Handler.post(Runnable) 来使用,这样事件的处理自然就在 run 方法中实现。

上面介绍了 Handler 是如何联系上了需要操作的线程与对消息是如何取出与处理的。下面来谈谈消息是如何放入到 Looper 中的 MessageQueue 中的。

sendMessageAtTime

通过 Handler 发送消息的方式很多,例如: sendMessagesendEmptyMessagesendMessageDelayed 等,其实到最后他们调用的都是 sendMessageAtTime 方法。所以还是来看下 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);
 }

sendMessageAtTime 则就是调用了 enqueueMessage 操作,看这方法名就知道是入队列操作了。

enqueueMessage

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

果不其然直接调用了 MessageQueue 中的 queue.enqueueMessage(msg, uptimeMillis) 将消息加入消息队列,同时这段代码 msg.target = this 将当前的 Handler 赋给了 msg.target ,这就是前面所说的 Looper.loop 方法中调用的 Handler 。这样就把消息放到了 MessageQueue 中,进而通过前面所讲的 loop 来取出消息进行相应的处理,这样就构成了整个对消息进行处理的系统。这也是使用 Handler 内部所发生的原理。好了 HandlerLooperMessageQueue 它们之间的联系基本就是这些了。我也简单画了张图希望有所帮助

Handler、Looper与MessageQueue源码分析

总结

来总结下它们之间的流程。首先创建 Handler 而在 Handler 所处的线程中必须要有一个 Looper ,如果在主线程中默认帮我们实现了,其他线程必须调用 Looper.prepare 来创建 Looper 同时调用 Looper.loop 开启对消息的处理。每个 Looper 中都有一个 MessageQueue 它是用来存储 Message 的, Handler 通过 post 或者 send.. 等一系列操作通过 Looper 将消息放入到消息队列中,而 Looper 通过开启一个无限的循环来一直监听着消息的处理,不断从 MessageQueue 中取出消息,并交给与当前 Looper 所绑定的 handlerdispatchMessage 进行分发,最后根据情况调用 Runnablerun 或者 HandlerHandlerMessage 方法对消息进行最后的处理。

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址