我是代码搬运工，不能仅仅只是搬运，还要整理一下。
1. Handler组成部分：
- Message：消息
- Handler：消息的发起者
- Looper：消息的遍历者
- MessageQueue：消息队列
Handler流程图
2. Handler的使用流程：
使用Handler之前的准备工作有三步：
-
调用Looper.prepare()（主线程不需要调这个，因为APP创建时，main方法里面已经帮我们创建了）
-
创建Handler对象，重写handleMessage方法（你可以不重写），用于处理message回调的
-
调用Looper.loop()
其中：
Looper.prepare()的作用主要有以下三点：
-
创建Looper对象
-
创建MessageQueue对象，并让Looper对象持有
-
让Looper对象持有当前线程
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
// 规定了一个线程只有一个Looper，也就是一个线程只能调用一次Looper.prepare()
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
// 如果当前线程没有Looper，那么就创建一个，存到sThreadLocal中
sThreadLocal.set(new Looper(quitAllowed));
}
从上面的代码可以看出，一个线程最多只有一个Looper对象。当没有Looper对象时，去创建一个Looper，并存放到sThreadLocal中
private Looper(boolean quitAllowed) {
// 创建了MessageQueue，并供Looper持有
mQueue = new MessageQueue(quitAllowed);
// 让Looper持有当前线程对象
mThread = Thread.currentThread();
}
这里主要就是创建了消息队列MessageQueue，并让它供Looper持有，因为一个线程最多只有一个Looper对象，所以一个线程最多也只有一个消息队列。然后再把当前线程赋值给mThread。
Handler使用流程：
-
Handler.post(或sendMessage）： handler发送消息msg
-
MessageQueue.enqueueMessage(msg, uptimeMillis)：msg加入message队列
-
loop() 方法中从MessageQue中取出msg，然后回调handler的dispatchMessage，然后执行callback(如果有的话) 或 handleMessage。（注意，loop方法是一直在循环的，从前面的handler准备工作开始就已经一直在运行了）
如图所示：
ThreadLocal
3. Handler具体源码：
3.1. Message获取
Message的获取方式有两种：
1. Message msg = new Message();
2. Message msg = Message.obtain();
从全局池返回一个新的消息实例。允许我们在许多情况下避免分配新对象。
/**
* Return a new Message instance from the global pool. Allows us to
* avoid allocating new objects in many cases.
*/
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;
}
}
return new Message();
}
复用之前用过的 Message 对象，这里实际上是用到了一种享元设计模式，这种设计模式最大的特点就是复用对象，避免重复创建导致的内存浪费
/**
* Recycles a Message that may be in-use.
* Used internally by the MessageQueue and Looper when disposing of queued Messages.
*/
void recycleUnchecked() {
// Mark the message as in use while it remains in the recycled object pool.
// Clear out all other details.
flags = FLAG_IN_USE;
what = 0;
arg1 = 0;
arg2 = 0;
obj = null;
replyTo = null;
sendingUid = -1;
when = 0;
target = null;
callback = null;
data = null;
synchronized (sPoolSync) {
if (sPoolSize < MAX_POOL_SIZE) {
next = sPool;
sPool = this;
sPoolSize++;
}
}
}
每次message使用完了之后会调用recycleUnchecked回收message，方便下次使用
Message核心的信息有这些：
public int what;
public int arg1;
public int arg2;
public Object obj;
/*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;
3.2 Handler的发送消息
handler提供的发送消息的方法有很多，大致分为两类：
- Handler.post(xxx);
- Handler.sendMessage(xxx);
虽然方法很多，但最终都会回调到这个方法：
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
这个方法就是将消息添加到队列里。
3.3 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(TAG, e.getMessage(), e);
msg.recycle();
return false;
}
// 标记这个 Message 已经被使用
msg.markInUse();
msg.when = when;
// 这是这个消息队列里的目前第一条待处理的消息（当前消息队列的头部，有可能为空）
Message p = mMessages;
boolean needWake;
// 如果目前队列里没有消息 或 这条消息msg需要立即执行 或 这条消息msg的延迟时间比队列里的第一条待处理的消息还要早的话，走这个逻辑
if (p == null || when == 0 || when < p.when) {
// 把消息插入到消息队列的头部
// 最新的消息，如果已经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循环的作用就是找出msg应该放置的正确位置
// 经过下面这个for循环，最终会找出msg的前一个消息是prev，后一个消息是p
for (;;) {
prev = p;
p = p.next;
if (p == null || when < p.when) {
break;
}
if (needWake && p.isAsynchronous()) {
needWake = false;
}
}
// 上面的for循环得出的结果就是：msg应该在prev后面，在p前面
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;
}
上面就是handler发送消息过来，然后添加到消息队列里。
下面就开始讲添加消息到队列之后的事情：取消息，然后执行。
3.4 Loop的取消息
前面已经说到，在使用Handler之前有三步准备工作：
-
调用Looper.prepare()（主线程不需要调这个，因为APP创建时，main方法里面已经帮我们创建了）
-
创建Handler对象，重写handleMessage方法（你可以不重写），用于处理message回调的
-
调用Looper.loop()
其中第三步的Looper.loop()的作用就是不断的从MessageQueue队列里取消息，也就是说，在使用handler发消息之前，就已经开始了loop的循环了。
loop()源码比较长，这里摘取核心部分：
/**
* Run the message queue in this thread. Be sure to call
* {@link #quit()} to end the loop.
*
* 大概的翻译就是：在这个线程中运行消息队列。确保调用{@link #quit()}来结束循环。
*
*/
public static void loop() {
····
····
for (;;) {
// 不断的从MessageQueue的next方法里取出队列的头部消息
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
·····
·····
·····
try {
// msg.target是Message在创建时传入的Handler，也就是发送这条消息的发送者handler
// 所以最终会回调到handler的dispatchMessage方法
msg.target.dispatchMessage(msg);
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
····
····
// 回收msg，重复利用
msg.recycleUnchecked();
}
}
loop()的作用就是不断的从MessageQueue里取消息，然后回调到dispatchMessage里，再看看dispatchMessage里干啥了
/**
* 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);
}
}
所以最终会执行callback或handleMessage。
简书对文章长度有限制，剩下的放到下一篇文章：
（Handler知识收集整理-2）
网友评论