1. 技术文章
  2. Android Looper和Handler分析

Android Looper和Handler分析

由 只愿长相守 提交于 2020-03-02 12:29:19

Android应用程序是通过消息来驱动的，每个应用程序都有一个Main looper在ActivityThread中创建。我们这一节中就主要来分析下Looper和Handler的实现机制，首先来简单介绍一下它们的关系：

▪Thread、Looper、MessageQueue、Handler的关系
–Thread线程是整个Looper循环执行的场所
–Looper消息泵，不断的从MessageQueue中读取消息并执行，Looper就是一个无限循环，Looper中包含MessageQueue
–MessageQueue消息队列，负责存放消息
–Looper分发消息给Handler执行；Handler同时可以向MessageQueue添加消息

我们通过下面一个简单的程序来看一下如何使用Looper和Handler：
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. class LooperThread extends Thread {  
  2.     public Handler mHandler;  
  3.     public void run() {  
  4.         Looper.prepare();  
  5.         mHandler = new Handler() {  
  6.                  public void handleMessage(Message msg) {  
  7.                      // process incoming messages here  
  8.                       }  
  9.                  };  
  10.          Looper.loop();  
  11.          }  
  12.      }  

首先在一个Thread中需要先调用Looper.prepare方法去做好初始化工作，其实就是实例化一个MessageQueue。然后调用Looper.loop就可以开始循环了。那我们首先先看一下prepare方法：

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public static void prepare() {  
  2.     prepare(true);  
  3. }  
  4. private static void prepare(boolean quitAllowed) {  
  5.     if (sThreadLocal.get() != null) {  
  6.         throw new RuntimeException("Only one Looper may be created per thread");  
  7.     }  
  8.     sThreadLocal.set(new Looper(quitAllowed));  
  9. }  
  10.   
  11. private Looper(boolean quitAllowed) {  
  12.     mQueue = new MessageQueue(quitAllowed);  
  13.     mThread = Thread.currentThread();  
  14. }  

可以看到在prepare方法中主要是构造一个Looper对象并存放在sThreadLocal中，sThreadLocal是线程本地存储的变量，每个线程有这么一块区域来存储线程的数据，这些数据不会被进程中其它线程所修改。在Looper的构造函数中实例化一个MessageQueue对象：
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1.     MessageQueue(boolean quitAllowed) {  
  2.         mQuitAllowed = quitAllowed;  
  3.         mPtr = nativeInit();  
  4.     }  
  5.   
  6. static jint android_os_MessageQueue_nativeInit(JNIEnv* env, jclass clazz) {  
  7.     NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue();  
  8.     if (!nativeMessageQueue) {  
  9.         jniThrowRuntimeException(env, "Unable to allocate native queue");  
  10.         return 0;  
  11.     }  
  12.   
  13.     nativeMessageQueue->incStrong(env);  
  14.     return reinterpret_cast<jint>(nativeMessageQueue);  
  15. }  

在MessageQueue的构造函数中通过JNI调用到android_os_MessageQueue_nativeInit方法，在这个方法里面，构造一个NativeMessageQueue对象，并在Java层的MessageQueue成员变量mPtrl保存NativeMessageQueue对象的内存地址，以便后面Java层调用NativeMessageQueue的其它方法。我们再来看一下NativeMessageQueue的构造函数：
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. NativeMessageQueue::NativeMessageQueue() : mInCallback(false), mExceptionObj(NULL) {  
  2.     mLooper = Looper::getForThread();  
  3.     if (mLooper == NULL) {  
  4.         mLooper = new Looper(false);  
  5.         Looper::setForThread(mLooper);  
  6.     }  
  7. }  
在Native层的MessageQueue中，也通过TLS技术在线程中保存是否创建了底层Looper，如果有创建就可以通过getForThread返回；如果没有，getForThread将返回NULL。当然这里肯定会返回NULL，这里就将构造一个Looper对象并设置到这个线程的TLS中。我们来看Looper的构造函数：
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. Looper::Looper(bool allowNonCallbacks) :  
  2.         mAllowNonCallbacks(allowNonCallbacks), mSendingMessage(false),  
  3.         mResponseIndex(0), mNextMessageUptime(LLONG_MAX) {  
  4.     int wakeFds[2];  
  5.     int result = pipe(wakeFds);  
  6.     LOG_ALWAYS_FATAL_IF(result != 0, "Could not create wake pipe.  errno=%d", errno);  
  7.   
  8.     mWakeReadPipeFd = wakeFds[0];  
  9.     mWakeWritePipeFd = wakeFds[1];  
  10.   
  11.     result = fcntl(mWakeReadPipeFd, F_SETFL, O_NONBLOCK);  
  12.     LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake read pipe non-blocking.  errno=%d",  
  13.             errno);  
  14.   
  15.     result = fcntl(mWakeWritePipeFd, F_SETFL, O_NONBLOCK);  
  16.     LOG_ALWAYS_FATAL_IF(result != 0, "Could not make wake write pipe non-blocking.  errno=%d",  
  17.             errno);  
  18.   
  19.     mIdling = false;  
  20.   
  21.     // Allocate the epoll instance and register the wake pipe.  
  22.     mEpollFd = epoll_create(EPOLL_SIZE_HINT);  
  23.     LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance.  errno=%d", errno);  
  24.   
  25.     struct epoll_event eventItem;  
  26.     memset(& eventItem, 0, sizeof(epoll_event)); // zero out unused members of data field union  
  27.     eventItem.events = EPOLLIN;  
  28.     eventItem.data.fd = mWakeReadPipeFd;  
  29.     result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeReadPipeFd, & eventItem);  
  30.     LOG_ALWAYS_FATAL_IF(result != 0, "Could not add wake read pipe to epoll instance.  errno=%d",  
  31.             errno);  
  32. }  

Looper的构造函数比较简单，首先构造一个pipe，一端用于读，另一端用于写。然后使用epoll将它mWakeReadPipeFd添加到mEpollFd中。后面我们就可以通过在mWakeWritePipeFd端写数据，让epoll_wait跳出等待。当这里Looper.prepare函数就介绍完了，我们先来看一下上面说到的几个类的关系图：





然后我们再来分析Looper.loop方法：
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public static void loop() {  
  2.     final Looper me = myLooper();  
  3.     final MessageQueue queue = me.mQueue;  
  4.     Binder.clearCallingIdentity();  
  5.     final long ident = Binder.clearCallingIdentity();  
  6.     for (;;) {  
  7.         Message msg = queue.next(); // might block  
  8.         if (msg == null) {  
  9.             return;  
  10.         }  
  11.         msg.target.dispatchMessage(msg);  
  12.         final long newIdent = Binder.clearCallingIdentity();  
  13.         msg.recycle();  
  14.     }  
  15. }  
首先myLooper返回ThreadLocal存储的前面构造的Looper对象。然后调用Looper中的MessageQueue的next方法，next方法返回下一个消息（如果有，如果没有就一直等待），当然一般情况下不会返回空消息。并调用msg.target的dispatchMessage方法，这里的target其实就是Handler，我们后面再来分析。先来看一下MessageQueue的next方法：
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. Message next() {  
  2.      int pendingIdleHandlerCount = -1; // -1 only during first iteration  
  3.      int nextPollTimeoutMillis = 0;  
  4.      for (;;) {  
  5.          if (nextPollTimeoutMillis != 0) {  
  6.              Binder.flushPendingCommands();  
  7.          }  
  8.          nativePollOnce(mPtr, nextPollTimeoutMillis);  
  9.          synchronized (this) {  
  10.              final long now = SystemClock.uptimeMillis();  
  11.              Message prevMsg = null;  
  12.              Message msg = mMessages;  
  13.              if (msg != null && msg.target == null) {  
  14.                  do {  
  15.                      prevMsg = msg;  
  16.                      msg = msg.next;  
  17.                  } while (msg != null && !msg.isAsynchronous());  
  18.              }  
  19.              if (msg != null) {  
  20.                  if (now < msg.when) {  
  21.                      nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);  
  22.                  } else {  
  23.                      mBlocked = false;  
  24.                      if (prevMsg != null) {  
  25.                          prevMsg.next = msg.next;  
  26.                      } else {  
  27.                          mMessages = msg.next;  
  28.                      }  
  29.                      msg.next = null;  
  30.                      msg.markInUse();  
  31.                      return msg;  
  32.                  }  
  33.              } else {  
  34.                  nextPollTimeoutMillis = -1;  
  35.              }  
  36.              if (mQuitting) {  
  37.                  dispose();  
  38.                  return null;  
  39.              }  
  40.   
  41.              if (pendingIdleHandlerCount < 0  
  42.                      && (mMessages == null || now < mMessages.when)) {  
  43.                  pendingIdleHandlerCount = mIdleHandlers.size();  
  44.              }  
  45.              if (pendingIdleHandlerCount <= 0) {  
  46.                  // No idle handlers to run.  Loop and wait some more.  
  47.                  mBlocked = true;  
  48.                  continue;  
  49.              }  
  50.              if (mPendingIdleHandlers == null) {  
  51.                  mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];  
  52.              }  
  53.              mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);  
  54.          }  
  55.   
  56.          for (int i = 0; i < pendingIdleHandlerCount; i++) {  
  57.              final IdleHandler idler = mPendingIdleHandlers[i];  
  58.              mPendingIdleHandlers[i] = null; // release the reference to the handler  
  59.              boolean keep = false;  
  60.              try {  
  61.                  keep = idler.queueIdle();  
  62.              } catch (Throwable t) {  
  63.                  Log.wtf("MessageQueue", "IdleHandler threw exception", t);  
  64.              }  
  65.              if (!keep) {  
  66.                  synchronized (this) {  
  67.                      mIdleHandlers.remove(idler);  
  68.                  }  
  69.              }  
  70.          }  
  71.          pendingIdleHandlerCount = 0;  
  72.          nextPollTimeoutMillis = 0;  
  73.      }  
  74.  }  

next函数虽然比较长，但它的逻辑还是比较简单的，主要可以分为下面三个步骤：
▪调用nativePollOnce去完成等待。初始值nextPollTimeoutMillis为0，epoll_wait会马上返回，当nextPollTimeoutMillis为-1，epoll_wait会一直等待
▪当nativePollOnce返回后，获取mMessages中消息。如果mMessages没有消息，就设置nextPollTimeoutMillis为-1，表示下一次epoll_wait时一直等待。如果mMessages中有消息，并且当前系统时间不小于messge待处理的时间，就返回这个消息
▪如果没有消息处理，并且当前有IdleHandlers，就调用IdleHandlers的queueIdle方法，并修改nextPollTimeoutMillis为0。IdleHandlers用于在MessageQueue中没有消息时做回调使用。

在上面的三个步骤中，最重要的当然是nativePollOnce，我们来简单分析一下：
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. void NativeMessageQueue::pollOnce(JNIEnv* env, int timeoutMillis) {  
  2.     mInCallback = true;  
  3.     mLooper->pollOnce(timeoutMillis);  
  4.     mInCallback = false;  
  5.     if (mExceptionObj) {  
  6.         env->Throw(mExceptionObj);  
  7.         env->DeleteLocalRef(mExceptionObj);  
  8.         mExceptionObj = NULL;  
  9.     }  
  10. }  
  11.   
  12. int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {  
  13.     int result = 0;  
  14.     for (;;) {  
  15.   
  16.   
  17.         if (result != 0) {  
  18.             return result;  
  19.         }  
  20.   
  21.         result = pollInner(timeoutMillis);  
  22.     }  
  23. }  
  24.   
  25. int Looper::pollInner(int timeoutMillis) {  
  26.     int result = ALOOPER_POLL_WAKE;  
  27.     mResponses.clear();  
  28.     mResponseIndex = 0;  
  29.   
  30.     // We are about to idle.  
  31.     mIdling = true;  
  32.   
  33.     struct epoll_event eventItems[EPOLL_MAX_EVENTS];  
  34.     int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);  
  35.   
  36.     // No longer idling.  
  37.     mIdling = false;  
  38.   
  39.     // Acquire lock.  
  40.     mLock.lock();  
  41.   
  42.     if (eventCount < 0) {  
  43.         if (errno == EINTR) {  
  44.             goto Done;  
  45.         }  
  46.         ALOGW("Poll failed with an unexpected error, errno=%d", errno);  
  47.         result = ALOOPER_POLL_ERROR;  
  48.         goto Done;  
  49.     }  
  50.   
  51.     // Check for poll timeout.  
  52.     if (eventCount == 0) {  
  53. #if DEBUG_POLL_AND_WAKE  
  54.         ALOGD("%p ~ pollOnce - timeout", this);  
  55. #endif  
  56.         result = ALOOPER_POLL_TIMEOUT;  
  57.         goto Done;  
  58.     }  
  59.   
  60.     for (int i = 0; i < eventCount; i++) {  
  61.         int fd = eventItems[i].data.fd;  
  62.         uint32_t epollEvents = eventItems[i].events;  
  63.         if (fd == mWakeReadPipeFd) {  
  64.             if (epollEvents & EPOLLIN) {  
  65.                 awoken();  
  66.             } else {  
  67.             }  
  68.         } else {  
  69.   
  70.         }  
  71.     }  
  72. Done: ;  
  73.   
  74.     mNextMessageUptime = LLONG_MAX;  
  75.     mLock.unlock();  
  76.     return result;  
  77. }  

因为Native层Looper需要支持底层自己的消息处理机制，所以pollOnce的代码中添加处理底层Message的代码，我们抛开这部分的代码，其实pollOnce就是调用epoll_wait去等待时间发生。当timeoutMillis为0时，它会立即返回；当timeoutMillis为-1时，它会一直等待，知道我们调用Looper::wake方法向mWakeWritePipeFd写入数据。我们简要来看一下上面介绍prepare和loop的流程：



我们再来分析下Handler和Message的关系，并介绍如何向MessageQueue中添加消息，以便epoll_wait能够返回。首先来看Handler的构造函数，Handler有很多构造函数，我们可以把Handler绑定到一个Looper上，也可以不带Looper参数，它会默认的绑定到我们的MainThread中：
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public Handler(Callback callback) {  
  2.     this(callback, false);  
  3. }  
  4.   
  5. public Handler(Looper looper) {  
  6.     this(looper, null, false);  
  7. }  
  8.   
  9. public Handler(Callback callback, boolean async) {  
  10.     mLooper = Looper.myLooper();  
  11.     if (mLooper == null) {  
  12.         throw new RuntimeException(  
  13.             "Can't create handler inside thread that has not called Looper.prepare()");  
  14.     }  
  15.     mQueue = mLooper.mQueue;  
  16.     mCallback = callback;  
  17.     mAsynchronous = async;  
  18. }  
  19.   
  20. public Handler(Looper looper, Callback callback, boolean async) {  
  21.     mLooper = looper;  
  22.     mQueue = looper.mQueue;  
  23.     mCallback = callback;  
  24.     mAsynchronous = async;  
  25. }  

上面列举了两种Handler的构造方法，它主要从当前Looper中得到MessageQueue对象，并保存在mQueue中，后面我们就可以调用mQueue的方法来添加消息了。来看一下Handler和Message的类图：



来看一下一个简单的sendMessage方法，当然Message对象可以通过Message的静态方法obtain获得：
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public final boolean sendMessage(Message msg)  
  2. {  
  3.     return sendMessageDelayed(msg, 0);  
  4. }  
  5.   
  6. public final boolean sendMessageDelayed(Message msg, long delayMillis)  
  7. {  
  8.     if (delayMillis < 0) {  
  9.         delayMillis = 0;  
  10.     }  
  11.     return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);  
  12. }  
  13.   
  14. public boolean sendMessageAtTime(Message msg, long uptimeMillis) {  
  15.     MessageQueue queue = mQueue;  
  16.     return enqueueMessage(queue, msg, uptimeMillis);  
  17. }  
  18.   
  19. private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {  
  20.     msg.target = this;  
  21.     if (mAsynchronous) {  
  22.         msg.setAsynchronous(true);  
  23.     }  
  24.     return queue.enqueueMessage(msg, uptimeMillis);  
  25. }  

这里经过一系列的方法，最终调用到MessageQueue的enqueueMessage函数：
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. boolean enqueueMessage(Message msg, long when) {  
  2.     if (msg.target == null) {  
  3.         throw new AndroidRuntimeException("Message must have a target.");  
  4.     }  
  5.     synchronized (this) {  
  6.         msg.when = when;  
  7.         Message p = mMessages;  
  8.         boolean needWake;  
  9.         if (p == null || when == 0 || when < p.when) {  
  10.             msg.next = p;  
  11.             mMessages = msg;  
  12.             needWake = mBlocked;  
  13.         } else {  
  14.             needWake = mBlocked && p.target == null && msg.isAsynchronous();  
  15.             Message prev;  
  16.             for (;;) {  
  17.                 prev = p;  
  18.                 p = p.next;  
  19.                 if (p == null || when < p.when) {  
  20.                     break;  
  21.                 }  
  22.                 if (needWake && p.isAsynchronous()) {  
  23.                     needWake = false;  
  24.                 }  
  25.             }  
  26.             msg.next = p; // invariant: p == prev.next  
  27.             prev.next = msg;  
  28.         }  
  29.         // We can assume mPtr != 0 because mQuitting is false.  
  30.         if (needWake) {  
  31.             nativeWake(mPtr);  
  32.         }  
  33.     }  
  34.     return true;  
  35. }  


enqueueMessage检查mMessages中是否有消息，如果没有，就把它当前头添加到mMessages中，并更新needWake为mBlocked，mBlocked会在mMessages为空并且没有IdleHandlers时置为true，这时timeoutMillis为-1，epoll_wait会无限等待，所以我们需要调用natvieWake唤醒它；如果在mMessages有消息，我们一般情况下不需要调用nativeWake来唤醒，除非我们当前头部是barrier消息（target为NULL）并且待send的消息是第一个异步的，这里就将调用nativeWake来唤醒它。这里注意的是异步消息不会被barrier消息打断，并且异步消息可以在它之前的同步消息之前执行。再来看一下nativeWake函数的实现：
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. static void android_os_MessageQueue_nativeWake(JNIEnv* env, jclass clazz, jint ptr) {  
  2.     NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);  
  3.     return nativeMessageQueue->wake();  
  4. }  
  5.   
  6. void Looper::wake() {  
  7.     ssize_t nWrite;  
  8.     do {  
  9.         nWrite = write(mWakeWritePipeFd, "W", 1);  
  10.     } while (nWrite == -1 && errno == EINTR);  
  11.   
  12.     if (nWrite != 1) {  
  13.         if (errno != EAGAIN) {  
  14.             ALOGW("Could not write wake signal, errno=%d", errno);  
  15.         }  
  16.     }  
  17. }  

这里其实就是向pipe的写端写入一个"W"字符，这样epoll_wait就可以跳出等待了。我们先来看一下上面介绍的sendMessage的流程：



当Message的next方法返回一个消息后，后面就将调用Handler的dispatchMessage去处理它：
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public void dispatchMessage(Message msg) {  
  2.     if (msg.callback != null) {  
  3.         handleCallback(msg);  
  4.     } else {  
  5.         if (mCallback != null) {  
  6.             if (mCallback.handleMessage(msg)) {  
  7.                 return;  
  8.             }  
  9.         }  
  10.         handleMessage(msg);  
  11.     }  
  12. }  

当我们post一个Runnable时，Message的callback就为这个Runnable，如果Runnable不为空，直接调用callback.run方法。如果msg.callback为空，但mCallback不为空，则调用mCallback的handleMessage方法。最后两者都没有的情况下才调用Handler的handleMessage方法，所以我们在程序中一般重载handleMessage来处理消息即可。下面是dispatchMessage的流程图：




我们来看下面这段代码：
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. class LooperThread extends Thread {  
  2.     public Looper myLooper = null;  
  3.     public void run() {  
  4.         Looper.prepare();  
  5.         myLooper = Looper.myLooper();  
  6.         Looper.loop();  
  7.         }  
  8. }  
  9.   
  10. {  
  11.     LooperThread myLooperThread = new LooperThread();  
  12.     myLooperThread.start();  
  13.     Looper mLooper = myLooperThread.myLooper;  
  14.     Handler mHandler = new Handler(mLooper);  
  15.     mHandler.sendEmptyMessage(0);  
  16. }  

这在我们程序中会经常用到，先在一个Thread中准备好Looper，然后使用这个Looper绑定到另外一个Handler上面。但上面的程序有点bug，当myLooperThread还没执行到myLooper = Looper.myLooper()这一行时，主线程接着运行并调用Handler的构造函数，因为此时MessageQueue还没准备好，所以这里会抛出一个异常。为了处理这种问题，Android提供了HandlerThread这个类来完美解决这个问题：
[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. public HandlerThread(String name, int priority) {  
  2.     super(name);  
  3.     mPriority = priority;  
  4. }  
  5.   
  6. public void run() {  
  7.     mTid = Process.myTid();  
  8.     Looper.prepare();  
  9.     synchronized (this) {  
  10.         mLooper = Looper.myLooper();  
  11.         notifyAll();  
  12.     }  
  13.     Process.setThreadPriority(mPriority);  
  14.     onLooperPrepared();  
  15.     Looper.loop();  
  16.     mTid = -1;  
  17. }  
  18.   
  19. public Looper getLooper() {  
  20.     if (!isAlive()) {  
  21.         return null;  
  22.     }  
  23.       
  24.     // If the thread has been started, wait until the looper has been created.  
  25.     synchronized (this) {  
  26.         while (isAlive() && mLooper == null) {  
  27.             try {  
  28.                 wait();  
  29.             } catch (InterruptedException e) {  
  30.             }  
  31.         }  
  32.     }  
  33.     return mLooper;  
  34. }  

通过wait和notifyAll机制完美解决了以上的问题。看来我们在程序中还是要多使用HandlerThread。下面对上面的介绍做一个简单的总结：

▪Handler的处理过程运行在创建Handler的线程里
▪一个Looper对应一个MessageQueue
▪一个线程对应一个Looper
▪一个Looper可以对应多个Handler
▪当MessageQueue中没有消息时，IdleHandlers会被回调
▪MessageQueue中的消息本来是有序的处理，但可以通过barrier消息将其中断（打乱）
标签
handler
looper
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!