Message，Handler是在Android中最常用的，更新UI点手段。与其他图形界面的原理类似，Android系统中UI也是靠消息驱动来工作的，具体有以下一些概念。
消息发送者：发生消息到队列
消息队列：存储消息的队列
消息循环：不断的循环取出消息，发给处理者
消息处理者：处理消息
他们的关系可以画成下图的样子：
消息机制原理图
消息循环Looper
Android消息循环由Looper类来实现。使用Looper要经过以下两个方法。
Looper.prepare();
Looper.loop();
在Activity主线程中查看就有Looper的初始化，查看ActivityThread类的main方法中，有下列代码
查看prepareMainLooper()方法第一句就调用了prepare方法。归根结底Looper的调用顺序先要调用prepare方法，然后再调用loop()方法。
1.Looper.prepare()
那我们先查看Looper的prepare方法
// sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
private static void prepare(boolean quitAllowed) {
// 保证一个线程Looper只能调用一次
// ThreadLocal并不是一个Thread，而是Thread的局部变量，
// 也许把它命名为ThreadLocalVariable更容易让人理解一些。
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}该方法很简单就是创建了一个Looper对象存入sThreadLocal中。
注意：ThreadLocal调用set存储，调用get获取。普通对象当在不同线程中获取时候是同一个对象，数据相同。然而ThreadLocal不同线程调用这个get，set获取到的数据是不同的，它是线程相关的局部变量。
综上一个线程只能存储一个Looper对象。
查看下Looper的构造函数。
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}构造函数主要就是创建了一个MessageQueue。
用图概括下
Looper.prepare()工作流程
prepare方法主要就是创建了Looper对象存在当前线程，同时Looper内创建了一个MessageQueue。
1.Looper.loop()
先看loop的源码
public static void loop() {
//取出当前线程相关的looper对象
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
//获取当前线程Looper对象内的MessageQueue（消息队列）
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.recycleUnchecked();
}
}查看loop方法，主要就是开启了消息循环,内部就是一个for循环一直获取一个个的Message调用msg.target.dispatchMessage处理。
1.获取调用线程的Looper对象，获取Looper对象内的MessageQueue
2.循环调用MessageQueue的next方法获取下一个元素
3.最终调用target的dispatchMessage方法处理Message。
4.继续步骤2
Looper.loop()工作流程
消息队列MessageQueue
MessageQueue主要提供了向队列插入Message的方法，获取下一个Message的方法。其类内部的成员变量
final MessageQueue mQueue;
为一个链表，存储所有的Message看下Message链表的结构应该是下图的样子
整个队列按照when变量从小到大排序，next变量指向下一个节点，其中的callback与target是消息最终的处理者。
上一节主要讲了loop方法内有个for循环，for内部会一直获取下一条Message。这里就看以下这个next方法。
MessageQueue的next方法是获取队列中的下一条Message
Message next() {
// Return here if the message loop has already quit and been disposed.
// This can happen if the application tries to restart a looper after quit
// which is not supported.
final long ptr = mPtr;//保存的是c++层的MessageQueue指针 供native层使用
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeoutMillis);//调用到c++层方法,可能阻塞在这里
synchronized (this) {
// Try to retrieve the next message. Return if found.
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
//target为null则是作为一个分隔符,普通的Message不返回,则向下遍历直到一个异步的message
// Stalled by a barrier. Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
//msg当前时间小于msg派发的时间,则计算当前到派发时间还需要多久 可能由于某种原因nativePollOnce返回,例如新插入了Message
// Next message is not ready. Set a timeout to wake up when it is ready.
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// Got a message.
//获得一个Message返回
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
msg.markInUse();
return msg;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}
// Process the quit message now that all pending messages have been handled.
if (mQuitting) {
dispose();
return null;
}
// If first time idle, then get the number of idlers to run.
// Idle handles only run if the queue is empty or if the first message
// in the queue (possibly a barrier) is due to be handled in the future.
//Message队列为空或者还没有到队列头部的Message派发时间 则执行下idel
if (pendingIdleHandlerCount < 0
&& (mMessages == null || now < mMessages.when)) {
pendingIdleHandlerCount = mIdleHandlers.size();
}
if (pendingIdleHandlerCount <= 0) {
//如果idle数目小于等于0 则进入下一次循环
// No idle handlers to run. Loop and wait some more.
mBlocked = true;
continue;
}
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
// Run the idle handlers.
// We only ever reach this code block during the first iteration.
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // release the reference to the handler
boolean keep = false;
try {
keep = idler.queueIdle();
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
// Reset the idle handler count to 0 so we do not run them again.
pendingIdleHandlerCount = 0;
// While calling an idle handler, a new message could have been delivered
// so go back and look again for a pending message without waiting.
nextPollTimeoutMillis = 0;
}
}这个next方法看似复杂，我们仔细梳理下它的条理。看看都做了什么
1.如果获取不到消息，让线程阻塞
2.如果有delay的Message，我们应该让阻塞一个定长的时间
3.如果有新的Message插入，应该重新调节阻塞时间
4.有一种特殊的Message是target为null。用来阻塞同步的Message
5.在空闲时间（队列为空，阻塞之前），执行些其他操作，比如垃圾回收。
MessageQueue中的一些native方法。
private native static long nativeInit();
private native void nativePollOnce(long ptr, int timeoutMillis); /*non-static for callbacks*/
private native static void nativeWake(long ptr);在看next方法的时候首先会遇到一个nativePollOnce方法，这里先说下它的功能。
nativePollOnce方法是个native方法，它的功能主要是让线程阻塞，第一个参数是native的MessageQueue指针，第二个参数比较重要，是需要阻塞的时间
当为-1的时候标志永久阻塞，为0的时候立刻返回，为正数的时候表示要阻塞的时间。
nativePollOnce方法阻塞的时候，其实是可以被唤醒的,
nativeWake方法被调用的时候，nativePollOnce就会被唤醒。
next方法里边有个for循环，这个函数里的for循环并不是起循环获取消息的作用，而是当阻塞的时候被唤醒，再次进入上述next流程，以便能返回一个Message，或者重新计算阻塞时间。
看下阻塞时间nextPollTimeoutMillis赋值的几种情况。
1.new<msg.when即当前时间还没到Message的派发时间呢，我们需要重新计算下一个Message的发生时间，这是因为我们在向队列插入新的Message的时候可能引起队列中按时间排序的链表的变化，获取的下一个Message可能已经不是上次循环的那个Message了
2.当获取的下一条Message为null，nextPollTimeoutMillis赋值为-1，这时候线程将永远阻塞，直到被nativeWake唤醒，一般在向队列中插入Message需要唤醒处理。
3.当idleHandler被处理之后nextPollTimeoutMillis赋值为0，由于idleHandler可能是耗时处理，完成后可能已经有Message到了发生时间了。
代码节选，这个分支处理是next 的核心逻辑
if (msg != null) {
if (now < msg.when) {
//msg当前时间小于msg派发的时间,则计算当前到派发时间还需要多久 可能由于某种原因nativePollOnce返回,例如新插入了Message
// Next message is not ready. Set a timeout to wake up when it is ready.
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// Got a message.
//获得一个Message返回
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
msg.markInUse();
return msg;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}idle的处理：
在ActivityThread中，在某种情况下会在消息队列中设置GcIdler，进行垃圾收集，其定义如下：
final class GcIdler implements MessageQueue.IdleHandler {
@Override
public final boolean queueIdle() {
doGcIfNeeded();
return false;
}
}一旦队列里设置了这个Idle Handler，那么当队列中没有马上需处理的消息时，就会进行垃圾收集。
综上中next方法流程如下
向队列中插入Message，要保证按时间排序，要处理分隔符Message，处理异步Message，看下插入的方法enqueueMessage。
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) {
//这里是直接插入队列头部, 需要唤醒next方法的阻塞 进行下一次循环
// 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.
//插入队列中间.通常不需要唤醒next方法 当遇队列首个Message为分隔栏,且插入的Message为异步的需要唤醒 目的是让这个异步的Message接受处理
needWake = mBlocked && p.target == null && msg.isAsynchronous();
Message prev;
//根据when遍历到合适的位置插入Message
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
//当前的Message是异步消息,并且不是第一个,不用唤醒了
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;
}由于MessageQueue中存储的是一个根据when字段从小到大排列的有序链表，向队列中插入数据，其实就是根据when字段把Message插入到链表的合适的位置。根据插入情况决定是否唤醒next方法。一般插入链表头部需要唤醒，因为头部刚插入的这个Message变成了下一个要执行的，需要知道他的状态，然后进行定时阻塞，或者直接返回。
Message分析
Message大概有三种：
普通Message
target变量为发送Message的Handler自己
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}Handler的enqueueMessage方法中第一句对msg的target进行了赋值
异步Message
通过Message的setAsynchronous方法来设置是否是异步Message，isAsynchronous方法来判断是否是异步Message，普通创建的Message为同步的
int flags;
public boolean isAsynchronous() {
return (flags & FLAG_ASYNCHRONOUS) != 0;
}
public void setAsynchronous(boolean async) {
if (async) {
flags |= FLAG_ASYNCHRONOUS;
} else {
flags &= ~FLAG_ASYNCHRONOUS;
}
}handler构造函数提供了一个参数，async来决，向队列插入的Message是否是异步Message
public Handler(Callback callback, boolean async)
public Handler(Looper looper, Callback callback, boolean async)Message分隔符
上次多次提到了target为null的Message，它始终特殊的Message，在队列中作为一个分隔符，以他为标志，后边的同步的Message将不会被looper处理。
看下MessageQueue的定义，这种Message只能通过MessageQueue的下列方法打入队列，不能自己直接构造Message打入队列。
MessageQueue提供了postSyncBarrier方法用于向队列中打入”分隔符”。
removeSyncBarrier方法用于移除队列中的”分隔符"
详细见以下源码
public int postSyncBarrier() {
return postSyncBarrier(SystemClock.uptimeMillis());
}
private int postSyncBarrier(long when) {
// Enqueue a new sync barrier token.
// We don't need to wake the queue because the purpose of a barrier is to stall it.
synchronized (this) {
final int token = mNextBarrierToken++;
final Message msg = Message.obtain();
msg.markInUse();
msg.when = when;
msg.arg1 = token;
Message prev = null;
Message p = mMessages;
if (when != 0) {
while (p != null && p.when <= when) {
prev = p;
p = p.next;
}
}
if (prev != null) { // invariant: p == prev.next
msg.next = p;
prev.next = msg;
} else {
msg.next = p;
mMessages = msg;
}
return token;
}
}
/**
* Removes a synchronization barrier.
*
* @param token The synchronization barrier token that was returned by
* {@link #postSyncBarrier}.
*
* @throws IllegalStateException if the barrier was not found.
*
* @hide
*/
public void removeSyncBarrier(int token) {
// Remove a sync barrier token from the queue.
// If the queue is no longer stalled by a barrier then wake it.
synchronized (this) {
Message prev = null;
Message p = mMessages;
while (p != null && (p.target != null || p.arg1 != token)) {
prev = p;
p = p.next;
}
if (p == null) {
throw new IllegalStateException("The specified message queue synchronization "
+ " barrier token has not been posted or has already been removed.");
}
final boolean needWake;
if (prev != null) {
prev.next = p.next;
needWake = false;
} else {
mMessages = p.next;
needWake = mMessages == null || mMessages.target != null;
}
p.recycleUnchecked();
// If the loop is quitting then it is already awake.
// We can assume mPtr != 0 when mQuitting is false.
if (needWake && !mQuitting) {
nativeWake(mPtr);
}
}
}
把所有的Message画入MessageQueue中如上图
处理者&发送者Handler
Handler主要封装了向MessageQueue添加Message的与处理Message的方法，让对MessageQueue的操作更简单
查看Handler中的成员变量，主要有以下两个
final MessageQueue mQueue;
final Looper mLooper;然后看下构造函数，看看他们的初始化过程
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;
}
public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
mCallback = callback;
mAsynchronous = async;
}主要有上边两个构造函数，第一个构造函数，获取当前线程的Looper对象与MessageQueue存储起来。
第二个构造函数，主要是从外部传入一个Looper对象，可以是其他线程Looper对象，然后存储这个Looper与他的MessageQueue
想想Handler的常用方法，一般会调用sendMessage，sendMessageDelayed，post的等相关方法发送一个Message，然后通过handler的handleMessage方法处理.
通过查询源码发现这些发送消息的方法都会调用Handler的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);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}原来最终是调用了MessageQueue的enqueueMessage方法，向队列插入消息，同时注意此时msg.target设置为了Handler自己。画图概括下发送消息的过程。
从第二个构造函数可知道，Handler内可以传入一个Looper对象，这样就可以传入其他线程的Looper，这样通过这个Handler就可以向其他线程消息循环发送Message了。
同时Handler也承担了处理Message的角色。上边说了在Looper的loop方法中，会一直循环获取MessageQueue的下一条消息处理，处理是调用
msg.target.dispatchMessage(msg);
target就是Handler类型，最终调用Handler的dispatchMessage方法处理消息
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}dispatchMessage中定义了一套消息处理优先级的机制
1.Message自己的callback，这种处理一般用在post相关方法发送消息的情况较多，例如post(new Runnable(){ run(){...} }) 。
2.Handler设置的全局callback，不常用。
3.交给Handler的handleMessage处理，通常需要子类中重写该方法来完成工作
至此JAVA已经分析完毕，知道那几个native方法的作用，不想了解他的原理，不看下边内容也可以。
Native层分析
我们这里主要遇到了下边几个native方法
private native static long nativeInit();
private native void nativePollOnce(long ptr, int timeoutMillis); /*non-static for callbacks*/
private native static void nativeWake(long ptr);上述方法的native实现在
[/frameworks/base/core/jni/android_os_MessageQueue.cpp]
static JNINativeMethod gMessageQueueMethods[] = {
/* name, signature, funcPtr */
{"nativeInit", "()J", (void*)android_os_MessageQueue_nativeInit},
{"nativeDestroy","(J)V",(void*)android_os_MessageQueue_nativeDestroy},
{"nativePollOnce","(JI)V",(void*)android_os_MessageQueue_nativePollOnce},
{"nativeWake","(J)V",(void*)android_os_MessageQueue_nativeWake},
{"nativeIsPolling","(J)Z",(void*)android_os_MessageQueue_nativeIsPolling},
{"nativeSetFileDescriptorEvents","(JII)V",
(void*)android_os_MessageQueue_nativeSetFileDescriptorEvents},
};
}这里看下android_os_MessageQueue方法
[/frameworks/base/core/jni/android_os_MessageQueue.cpp]
static jlong android_os_MessageQueue_nativeInit(JNIEnv* env, jclass clazz) {
NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue();
if (!nativeMessageQueue) {
jniThrowRuntimeException(env, "Unable to allocate native queue");
return 0;
}
nativeMessageQueue->incStrong(env);
return reinterpret_cast<jlong>(nativeMessageQueue);
}这个方法里边创建了一个nativeMessageQueue，继续看NativeMessageQueue的构造函数
[/frameworks/base/core/jni/android_os_MessageQueue.cpp]
NativeMessageQueue::NativeMessageQueue() :
mPollEnv(NULL), mPollObj(NULL), mExceptionObj(NULL) {
mLooper = Looper::getForThread();
if (mLooper == NULL) {
mLooper = new Looper(false);
Looper::setForThread(mLooper);
}
}在NativeMessageQueue的构造函数中创建了一个Looper对象，这个Looper是native层的，定义在/system/core/include/utils/Looper.h文件中
class Looper : public RefBase{
protected:
virtual~Looper();
public:
.......
Looper(bool allowNonCallbacks);
bool getAllowNonCallbacks()const;
int pollOnce(int timeoutMillis,int*outFd,int*outEvents,void**outData);
inline int pollOnce(int timeoutMillis){
return pollOnce(timeoutMillis,NULL,NULL,NULL);
}
.....
void wake();
int addFd(int fd,int ident,int events,Looper_callbackFunc callback,void*data);
int addFd(int fd,int ident,int events,const sp<LooperCallback>&callback,void*data);
int removeFd(int fd);
void sendMessage(const sp<MessageHandler>&handler,const Message&message);
void sendMessageDelayed(nsecs_t uptimeDelay,const sp<MessageHandler>&handler,const Message&message);
void sendMessageAtTime(nsecs_t uptime,const sp<MessageHandler>&handler,const Message&message);
void removeMessages(const sp<MessageHandler>&handler);
void removeMessages(const sp<MessageHandler>&handler,int what);
.......
}主要定义了一些fd与Message等操作的方法，和本地Message相关的变量，这里不是着重分析，native的消息机制，主要分析下整个流程。
上边的说到NativeMessageQueue的构造函数中，创建了一个Looper对象，看下Looper的构造函数都做了什么。
查看Looper的构造函数
[/system/core/libutils/Looper.cpp]
Looper::Looper(bool allowNonCallbacks) :
mAllowNonCallbacks(allowNonCallbacks), mSendingMessage(false),
mPolling(false), mEpollFd(-1), mEpollRebuildRequired(false),
mNextRequestSeq(0), mResponseIndex(0), mNextMessageUptime(LLONG_MAX) {
mWakeEventFd = eventfd(0, EFD_NONBLOCK);
LOG_ALWAYS_FATAL_IF(mWakeEventFd < 0, "Could not make wake event fd. errno=%d", errno);
AutoMutex _l(mLock);
rebuildEpollLocked();
}首先初始化了一大堆变量，此处不重要略过，直接看eventfd方法创建的对象。
eventfd具体与pipe有点像，用来完成两个线程之间事件触发。这个函数会创建一个 事件对象 (eventfd object), 用来实现，进程(线程)间 的 等待/通知(wait/notify) 机制. 内核会为这个对象维护一个64位的计数器(uint64_t)。并且使用第一个参数(initval)初始化这个计数器。调用这个函数就会返回一个新的文件描述符。
这个mWakeEventFd很重要，看下边的rebuildEpollLocked方法
[/system/core/libutils/Looper.cpp]
void Looper::rebuildEpollLocked() {
// Close old epoll instance if we have one.
//如果创建了epoll,关闭epoll
if (mEpollFd >= 0) {
close(mEpollFd);
}
// Allocate the new epoll instance and register the wake pipe.
// 创建一个epoll
mEpollFd = epoll_create(EPOLL_SIZE_HINT);
LOG_ALWAYS_FATAL_IF(mEpollFd < 0, "Could not create epoll instance. errno=%d", errno);
struct epoll_event eventItem;
memset(& eventItem, 0, sizeof(epoll_event)); // zero out unused members of data field union
eventItem.events = EPOLLIN;//表示对应的文件描述符可以读事件
eventItem.data.fd = mWakeEventFd;//Looper构造函数中eventfd函数返回的文件描述符
//注册新的fd到epoll中 监听文件可读事件
int result = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, mWakeEventFd, & eventItem);
LOG_ALWAYS_FATAL_IF(result != 0, "Could not add wake event fd to epoll instance. errno=%d",
errno);
for (size_t i = 0; i < mRequests.size(); i++) {//mRequests是个KeyedVector<int, Request>类型,遍历每个Request对象,把他们一次加入epoll中监听
const Request& request = mRequests.valueAt(i);
struct epoll_event eventItem;
request.initEventItem(&eventItem);
int epollResult = epoll_ctl(mEpollFd, EPOLL_CTL_ADD, request.fd, & eventItem);
if (epollResult < 0) {
ALOGE("Error adding epoll events for fd %d while rebuilding epoll set, errno=%d",
request.fd, errno);
}
}
}这里插入解释下epoll的作用。
epoll
epoll 是Linux内核中的一种可扩展IO事件处理机制，epoll会把被监听的文件发生了怎样的I/O事件通知我们。
native层主要就是利用了Linux提供的epoll机制，大家仔细了解下这个系统调用的作用，native层就没有什么难点了。
看下epoll的三个函数作用
int epoll_create(int size)
创建一个epoll的句柄。
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
epoll的事件注册函数epoll的事件注册函数
第一个参数是 epoll_create() 的返回值，第二个参数表示动作，第三个参数是需要监听的fd，第四个参数是告诉内核需要监听什么事件
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout)
等待事件的产生。参数events用来从内核得到事件的集合，maxevents表示每次能处理的最大事件数，告之内核这个events有多大，这个maxevents的值不能大于创建epoll_create()时的size，参数timeout是超时时间（毫秒，0会立即返回，-1将不确定，也有说法说是永久阻塞）。该函数返回需要处理的事件数目，如返回0表示已超时。
至此可以看到在构造Looper对象时，其内部除了创建了eventfd，还创建了一个epoll来监听eventfd。也就是说，是利用epoll机制来完成阻塞动作的。每当java层调用nativeWake的时候，最终会间接向eventfd写入数据，于是epoll立即就监听到了文件变化，epoll_wait()在等到事件后，随即进行相应的事件处理。这就是消息循环阻塞并处理的大体流程。
概括下nativeInit的流程：
nativePollOnce
在java层的next方法，首先调用的方法就是nativePollOnce 。然后看下native层的实现。nativePollOnce对应android_os_MessageQueue_nativePollOnce方法。看下这个方法。
[/frameworks/base/core/jni/android_os_MessageQueue.cpp]
static void android_os_MessageQueue_nativePollOnce(JNIEnv* env, jobject obj,jlong ptr, jint timeoutMillis) {
NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
nativeMessageQueue->pollOnce(env, obj, timeoutMillis);
}这里ptr就是定义在java层，MessageQueue中成员变量mPtr，强转成nativeMessageQueue
timeoutMillis就是java层中MessageQueue中传入的阻塞时间
该方法中直接调用了nativeInit创建的那个nativeMessageQueue的pollOnce方法。
[/frameworks/base/core/jni/android_os_MessageQueue.cpp]
void NativeMessageQueue::pollOnce(JNIEnv* env, jobject pollObj, int timeoutMillis) {
mPollEnv = env;
mPollObj = pollObj;
mLooper->pollOnce(timeoutMillis);
mPollObj = NULL;
mPollEnv = NULL;
if (mExceptionObj) {
env->Throw(mExceptionObj);
env->DeleteLocalRef(mExceptionObj);
mExceptionObj = NULL;
}
}pollOnce方法没有做什么，就是直接调用了Looper的pollOnce方法。
看下Looper的pollOnce方法
[/system/core/libutils/Looper.cpp]
int Looper::pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData) {
int result = 0;
for (;;) {
while (mResponseIndex < mResponses.size()) {
const Response& response = mResponses.itemAt(mResponseIndex++);
int ident = response.request.ident;
if (ident >= 0) {
int fd = response.request.fd;
int events = response.events;
void* data = response.request.data;
if (outFd != NULL) *outFd = fd;
if (outEvents != NULL) *outEvents = events;
if (outData != NULL) *outData = data;
return ident;
}
}
if (result != 0) {
if (outFd != NULL) *outFd = 0;
if (outEvents != NULL) *outEvents = 0;
if (outData != NULL) *outData = NULL;
return result;
}
result = pollInner(timeoutMillis);
}
}这里直接看最后一行，pollInner方法。这个方法比较长 ，主要注意epoll_wait方法，线程会阻塞在那里，等待事件的发生。
[/system/core/libutils/Looper.cpp]
int Looper::pollInner(int timeoutMillis) {
......
//阻塞在这里,到时间或者有事件发生返回
int eventCount = epoll_wait(mEpollFd, eventItems, EPOLL_MAX_EVENTS, timeoutMillis);
......
// Handle all events.
//处理所有epoll事件
for (int i = 0; i < eventCount; i++) {
int fd = eventItems[i].data.fd;
uint32_t epollEvents = eventItems[i].events;
if (fd == mWakeEventFd) {
if (epollEvents & EPOLLIN) {//当fd是eventfd且事件为EPOLLIN 则执行awoke方法 内部只是读取eventfd
awoken();
} else {
ALOGW("Ignoring unexpected epoll events 0x%x on wake event fd.", epollEvents);
}
} else {//如果是其他事件 则把request加入到mResponses中
ssize_t requestIndex = mRequests.indexOfKey(fd);
if (requestIndex >= 0) {
int events = 0;
if (epollEvents & EPOLLIN) events |= EVENT_INPUT;
if (epollEvents & EPOLLOUT) events |= EVENT_OUTPUT;
if (epollEvents & EPOLLERR) events |= EVENT_ERROR;
if (epollEvents & EPOLLHUP) events |= EVENT_HANGUP;
//内部调用mResponses.push(response);
pushResponse(events, mRequests.valueAt(requestIndex));
} else {
ALOGW("Ignoring unexpected epoll events 0x%x on fd %d that is "
"no longer registered.", epollEvents, fd);
}
}
}
Done: ;
// Invoke pending message callbacks.
mNextMessageUptime = LLONG_MAX;
//native层也有自己的Message,可以调用Looper::sendMessage,Looper::sendMessageDelayed方法进行发送Message
//发送出的Message会包装在MessageEnvelope中 然后加入mMessageEnvelopes中
//这里会循环处理所有的native层的Message
while (mMessageEnvelopes.size() != 0) {
nsecs_t now = systemTime(SYSTEM_TIME_MONOTONIC);
const MessageEnvelope& messageEnvelope = mMessageEnvelopes.itemAt(0);
if (messageEnvelope.uptime <= now) {
// Remove the envelope from the list.
// We keep a strong reference to the handler until the call to handleMessage
// finishes. Then we drop it so that the handler can be deleted *before*
// we reacquire our lock.
{ // obtain handler
sp<MessageHandler> handler = messageEnvelope.handler;
Message message = messageEnvelope.message;
mMessageEnvelopes.removeAt(0);
mSendingMessage = true;
mLock.unlock();
//调用MessageHandler的回调
handler->handleMessage(message);
} // release handler
mLock.lock();
mSendingMessage = false;
result = POLL_CALLBACK;
} else {
// The last message left at the head of the queue determines the next wakeup time.
//根据现在的队列头部的Message的uptime决定下一次唤醒时间
mNextMessageUptime = messageEnvelope.uptime;
break;
}
}
// Release lock.
mLock.unlock();
// Invoke all response callbacks.
//处理response
for (size_t i = 0; i < mResponses.size(); i++) {
Response& response = mResponses.editItemAt(i);
if (response.request.ident == POLL_CALLBACK) {
int fd = response.request.fd;
int events = response.events;
void* data = response.request.data;
// Invoke the callback. Note that the file descriptor may be closed by
// the callback (and potentially even reused) before the function returns so
// we need to be a little careful when removing the file descriptor afterwards.
int callbackResult = response.request.callback->handleEvent(fd, events, data);
if (callbackResult == 0) {
removeFd(fd, response.request.seq);
}
// Clear the callback reference in the response structure promptly because we
// will not clear the response vector itself until the next poll.
response.request.callback.clear();
result = POLL_CALLBACK;
}
}
return result;
}
默认系统只是创建了一个eventfd，等待他的事件发生，一进入上述方法可能回阻塞在epoll_wait方法，当eventfd有个风吹草动就回被唤醒，例如往里边写点东西。当唤醒后就处理下，读取eventfd里的数据。剩下的代码就是处理native层的Message队列中的消息。所以当你在JAVA层发送一个Message可能不会立刻执行，因为可能还在处理native层的消息。
可以看出JAVA层每次循环取出一个Message处理，而native层是每次把队列中的消息一次性处理完。
nativeWake
看看最后一个方法nativeWake
这个方法比较简单直接就是向下调用最后调用到了Looper的wake方法。
[/frameworks/base/core/jni/android_os_MessageQueue.cpp]
static void android_os_MessageQueue_nativeWake(JNIEnv* env, jclass clazz, jlong ptr) {
NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
nativeMessageQueue->wake();
}[/frameworks/base/core/jni/android_os_MessageQueue.cpp]
void NativeMessageQueue::wake() {
mLooper->wake();
}[/system/core/libutils/Looper.cpp]
void Looper::wake() {
uint64_t inc = 1;
ssize_t nWrite = TEMP_FAILURE_RETRY(write(mWakeEventFd, &inc, sizeof(uint64_t)));
if (nWrite != sizeof(uint64_t)) {
if (errno != EAGAIN) {
ALOGW("Could not write wake signal, errno=%d", errno);
}
}
}看看这个方法的功能，就是往mWakeEventFd里，就是初始化的时候eventfd函数创建的文件，中写入了一个uint64_t数字。因为epoll监听这个文件，所以epoll会立刻返回，这样pollOnce就可以继续向下执行了。
最后概括下native层之于JAVA层的作用：
