Android源码之Handler(三)

public Handler(Looper looper, Callback callback, boolean async) {
mLooper = looper;
mQueue = looper.mQueue;
[// mQueue = looper.mQueue
这里可以看出，Handler类的MessageQueue成员变量mQueue其实就是Looper内部的MessageQueue变量。
]// mQueue = looper.mQueue
mCallback = callback;
mAsynchronous = async;
}
[// public Handler(Looper looper, Callback callback, boolean async)
这个重载版本的构造函数的实现就是初始化Handler的几个成员变量。这几个成员变量的定义如下：
final MessageQueue mQueue;
final Looper mLooper;
final Callback mCallback;
[// final Callback mCallback
mCallback是Handler的Callback. 其实Message中会有一个Runnable类型的成员变量callback，这里为什么又要给Handler来定义一个Callback的成员变量呢？
Callback接口定义在Handler内部：
public interface Callback {
public boolean handleMessage(Message msg);
}
]// final Callback mCallback
final boolean mAsynchronous;
[// final boolean mAsynchronous
mAsynchronous表示Hanlder是否是异步的?在我们的认识中,Handler就是按照顺序来处理消息的, 这难道不是Handler的作用么?难道还可以异步的处理消息么？
]// final boolean mAsynchronous
由此可见，每一个Handler内部维护了一个Looper，而每一个Looper中又维护了一个MessageQueue.
这里我们就来看一下Looper的实现:

]// public Handler(Looper looper, Callback callback, boolean async)
Handler的一系列的构造函数中，其实最重要的就是两个:Handler(Callback callback, boolean async)和Handler(Looper looper, Callback callback, boolean async).
]// Handler的构造函数

当通过Handler构造函数得到了Handler对象之后, 会调用obtainMessage来得到一个Message对象. Android推介使用Handler的obtainMessage函数来得到一个Message对象，而不是直接构造一个Message对象, 为什么呢?
同样Handler类也提供了一系列的obtainMessage函数, 我们看一看obtainMessage函数的实现：
[// obtainMessage函数
public final Message obtainMessage()
{
return Message.obtain(this);
}
public final Message obtainMessage(int what)
{
return Message.obtain(this, what);
}
public final Message obtainMessage(int what, Object obj)
{
return Message.obtain(this, what, obj);
}
public final Message obtainMessage(int what, int arg1, int arg2)
{
return Message.obtain(this, what, arg1, arg2);
}
public final Message obtainMessage(int what, int arg1, int arg2, Object obj)
{
return Message.obtain(this, what, arg1, arg2, obj);
}
从以上代码也可以看出, Handler的obtainMessage函数其实是调用Message的obtain函数来实现的. 我们看一下Message类的obtain函数的实现：
[// Message类的obtain函数
public static Message obtain(Handler h) {
Message m = obtain();
m.target = h;

return m;
}
public static Message obtain(Handler h, Runnable callback) {
Message m = obtain();
m.target = h;
m.callback = callback;

return m;
}
public static Message obtain(Handler h, int what) {
Message m = obtain();
m.target = h;
m.what = what;

return m;
}
public static Message obtain(Handler h, int what, Object obj) {
Message m = obtain();
m.target = h;
m.what = what;
m.obj = obj;

return m;
}
public static Message obtain(Handler h, int what, int arg1, int arg2) {
Message m = obtain();
m.target = h;
m.what = what;
m.arg1 = arg1;
m.arg2 = arg2;

return m;
}
public static Message obtain(Handler h, int what,
int arg1, int arg2, Object obj) {
Message m = obtain();
m.target = h;
m.what = what;
m.arg1 = arg1;
m.arg2 = arg2;
m.obj = obj;

return m;
}

Message类同样提供了一系列的obtain的重载函数, 不过大同小异, 都是先调用obtain()函数得到一个Message对象,然后初始化这个Message对象，并返回该Message对象。
我们分析一下Message类的obtain函数的实现：
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--;
return m;
}
}
[// synchronized (sPoolSync)
上面这段代码就是从缓存中取Message。
其中定义了几个成员变量，分别为:
private static final Object sPoolSync = new Object();
private static Message sPool;
private static int sPoolSize = 0;
这些变量的作用都很明确. 注意:这些成员变量都是statics的。
]// synchronized (sPoolSync)
return new Message();
}
[// public static Message obtain()
Message的obtain函数的作用得到一个Message变量. 其实Android为Handler维护了一个Message的缓存, 调用obtain函数会首先尝试从缓存中取Message对象,而不是每次就构造一个Message对象。
这就是为什么推荐使用obtain函数来得到一个Message对象的原因。
我们简单来看一下Message的几个重要的成员变量:
public int what;
what成员变量是为了区分不同的Message.
public int arg1;
public int arg2;
public Object obj;
public Messenger replyTo;
public int sendingUid = -1;
/*package*/ static final int FLAG_IN_USE = 1 << 0;
/*package*/ static final int FLAG_ASYNCHRONOUS = 1 << 1;
/*package*/ static final int FLAGS_TO_CLEAR_ON_COPY_FROM = FLAG_IN_USE;

/*package*/ int flags;

/*package*/ long when;
when指示该消息需要被处理的时间戳
/*package*/ Bundle data;

/*package*/ Handler target;
target是最重要的成员变量. Android系统就是通过target找到这个Message所属于的Handler对象，然会调用这个Handler对象的handleMessage函数来处理该消息的
/*package*/ Runnable callback;
/*package*/ Message next;
private static final Object sPoolSync = new Object();
private static Message sPool;
private static int sPoolSize = 0;
private static final int MAX_POOL_SIZE = 50;
private static boolean gCheckRecycle = true;
]// public static Message obtain()
]// Message类的obtain函数
]// obtainMessage函数
经过上面的源码分析，我们可以明白Handler, Looper, MessageQueue和Message个关系了，也理解了这四者是如何配合从而完成Handler机制的。
下面我们分析一下发消息的过程，这主要是通过调用Handler的sendMessage和post函数完成的. Handler提供了一系列的send和post函数：
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
[// sendMessageDelayed(getPostMessage(r), 0)
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
]// sendMessageDelayed(getPostMessage(r), 0)
}
public final boolean postAtTime(Runnable r, long uptimeMillis)
{
return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}
public final boolean postAtTime(Runnable r, Object token, long uptimeMillis)
{
return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
[// return sendMessageAtTime(getPostMessage(r, token), uptimeMillis)
private static Message getPostMessage(Runnable r, Object token) {
Message m = Message.obtain();
m.obj = token;
m.callback = r;
return m;
}
]// return sendMessageAtTime(getPostMessage(r, token), uptimeMillis)
}
public final boolean postDelayed(Runnable r, long delayMillis)
{
return sendMessageDelayed(getPostMessage(r), delayMillis);
}
public final boolean postAtFrontOfQueue(Runnable r)
{
return sendMessageAtFrontOfQueue(getPostMessage(r));
}
public final boolean sendEmptyMessage(int what)
{
return sendEmptyMessageDelayed(what, 0);
}
public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageDelayed(msg, delayMillis);
}
public final boolean sendEmptyMessageAtTime(int what, long uptimeMillis) {
Message msg = Message.obtain();
msg.what = what;
return sendMessageAtTime(msg, uptimeMillis);
}
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
public final boolean sendMessageAtFrontOfQueue(Message msg) {
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, 0);
}
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);
}
上面这么多的函数(post用于发送Runnable, send用于发送Message)，其实都是很相似的。大致过程都成先得到一个Message, 然后调用enqueueMessage函数插入到消息队列中。
我们分析一下enqueueMessage函数的实现：
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
[// return queue.enqueueMessage(msg, uptimeMillis);
这里会调用MessageQueue的enqueueMessage函数来将Message插入到队列中，MessageQueue的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("MessageQueue", e.getMessage(), e);
msg.recycle();
return false;
}

msg.markInUse();
[// msg.markInUse()
将消息标记为正在使用
void markInUse() {
flags |= FLAG_IN_USE;
}
]// msg.markInUse()
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
[// if (p == null || when == 0 || when < p.when)
将消息插入到头部，这时候要唤醒Looper
]// if (p == null || when == 0 || when < p.when)
msg.next = p;
mMessages = msg;
needWake = mBlocked;
} else {
[// else
将消息插入到队列的中间
]// else
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);
[// nativeWake(mPtr)
这里调用nativeWake函数来唤醒Looper, 这也是个native函数，实际上调用的是android_os_MessageQueue.cpp中定义的android_os_MessageQueue_nativeWake函数。
android_os_MessageQueue_nativeWake的定义如下：
static void android_os_MessageQueue_nativeWake(JNIEnv* env, jclass clazz, jlong ptr) {
NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
return nativeMessageQueue->wake();
[// return nativeMessageQueue->wake()
这里调用的是NativeMessageQueue的wake函数.
void NativeMessageQueue::wake() {
mLooper->wake();
[// mLooper->wake()
这里又调用了C++层的wake函数，
void Looper::wake() {
#if DEBUG_POLL_AND_WAKE
ALOGD("%p ~ wake", this);
#endif

ssize_t nWrite;
do {
nWrite = write(mWakeWritePipeFd, "W", 1);
} while (nWrite == -1 && errno == EINTR);

if (nWrite != 1) {
if (errno != EAGAIN) {
ALOGW("Could not write wake signal, errno=%d", errno);
}
}
}
可以看到C++层的wake函数就是用mWakeWritePipeFd向管道里发送一个"w"字符，这样就会将epoll_wait函数来唤醒。
]// mLooper->wake()
}
]// return nativeMessageQueue->wake()
}
]// nativeWake(mPtr)
}
}
return true;
}
]// return queue.enqueueMessage(msg, uptimeMillis);
}