}
}
综合这两个示例，我们了解了Android消息机制的使用方法，也看到了发送消息、创建消息队列、开启消息循环以及处理消息的过程，下面给出一个更直观的“消息传递流程图”：
通过流程图可以看到整个消息传递过程，也可以看到在不同的阶段涉及的类：
-
消息发送：通过
Handler向关联的MessageQueue发送消息； -
消息存储: 把发送的消息以
Message的形式存储在MessageQueue中； -
消息循环：通过
Looper不停地从MessageQueue中获取消息，队列中没有消息时就阻塞等待新消息； -
消息分发和处理：
Looper获取消息后分发给Handler进行处理。
前面提到消息传递流程主要分为“发送消息”、“存储消息”、“消息循环”和“消息分发和处理”几个不同阶段，我本打算按照这个流程来分别讲解每个阶段，但是在具体行文的时候发现每个阶段并不是完全分割开来的，比如在讲“发送消息”之前要先了解“消息的存储结构”和“消息循环的开启”，而“消息的分发”又是属于“消息循环”的功能。
正是由于这几个阶段之间的相互关系，导致没有办法严格按照消息传递的顺序讲解Android消息机制。思虑再三，我决定通过上面讲解的Android消息机制通用示例来一步步解析其背后的逻辑流程。
再来看下通用示例：
class LooperThread extends Thread {
public Handler mHandler;
public void run() {
// 1. 初始化 Looper 对象，其内部会创建消息队列。
Looper.prepare();
mHandler = new Handler() {
public void handleMessage(Message msg) {
// 4. 处理消息队列中的消息。
}
};
// 2. 开启消息循环，会从消息队列中取出消息，没有消息时阻塞等待新消息的到来。
Looper.loop();
}
// 3. 发送消息
mHandler.sendEmptyMessage(0);
}
在示例代码中用不同的序号标注了“消息传递机制”的各个关键点，以下的内容也都是根据这些关键节点进行讲解的。
3.1 消息载体
“消息”是Android消息机制中信息的载体，它包含了在整个消息传递过程中想要传送的数据，要理解“消息机制”就要先了解这个消息载体类Message:
/**
-
Defines a message containing a description and arbitrary data object that can be
-
sent to a {@link Handler}. This object contains two extra int fields and an
-
extra object field that allow you to not do allocations in many cases.
-
While the constructor of Message is public, the best way to get
-
one of these is to call {@link #obtain Message.obtain()} or one of the
-
{@link Handler#obtainMessage Handler.obtainMessage()} methods, which will pull
-
them from a pool of recycled objects.
*/
public final class Message implements Parcelable { … }
Android框架中对消息载体Message的声明虽然简短，却传达了最核心最重要的两点信息：
Message的作用：Message是包含了描述信息和数据对象并且在消息机制中发送给Handler的对象，其中的数据对象主要包括两个整型域和一个对象域，通过这些域可以传递信息。整型的代价是最小的，所以尽量使用整型域传递信息。
/**
-
User-defined message code so that the recipient can identify
-
what this message is about. Each {@link Handler} has its own name-space
-
for message codes, so you do not need to worry about yours conflicting
-
with other handlers.
*/
public int what;
/**
-
arg1 and arg2 are lower-cost alternatives to using
-
{@link #setData(Bundle) setData()} if you only need to store a
-
few integer values.
*/
public int arg1;
public int arg2;
/**
-
An arbitrary object to send to the recipient. When using
-
{@link Messenger} to send the message across processes this can only
-
be non-null if it contains a Parcelable of a framework class (not one
-
implemented by the application). For other data transfer use
-
{@link #setData}.
-
Note that Parcelable objects here are not supported prior to
-
the {@link android.os.Build.VERSION_CODES#FROYO} release.
*/
public Object obj;
Message的创建方式：虽然Message有公有构造函数，但是建议使用其提供的obtain系列函数来获取Message对象，这种创建方式会重复利用缓存池中的对象而不是直接创建新的对象，从而避免在内存中创建太多对象，避免可能的性能问题。
/**
-
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) {
// 缓存池中存在可用对象时去缓存池获取 Message 对象。
if (sPool != null) {
// 获取缓存中的对象，并把缓存池指针后移。
Message m = sPool;
sPool = m.next;
m.next = null;
// 清除标志位
m.flags = 0; // clear in-use flag
// 更新当前缓存池大小
sPoolSize–;
return m;
}
}
// 缓存池中没有可用对象时直接创建一个新的 Message 对象。
return new Message();
}
Message中有一系列obtain函数用以在不同场景中获取对象，但这个是最核心的，其他函数都会在其内部调用它，有兴趣的同学可以自行查看源码，考虑到篇幅问题，这里就不再一一列举说明了。
看到这里，相信大家都会有一个疑问：obtain函数是从缓存池中获取Message对象，那缓存池中的对象是什么时候被添加进去的呢？既然缓存池中的对象都是一些可以被重复使用的对象，很明显是在Message对象不再被需要的时候，即从MessageQueue中取出并分发给Handler的时候，被添加到缓存中的，使用的是recycleUnchecked函数：
/**
-
Recycles a Message that may be in-use.
-
Used internally by the MessageQueue and Looper when disposing of queued Messages.
*/
void recycleUnchecked() {
// 设置标志位为“使用中”，在从缓存中取出时会清除这个标志位。
flags = FLAG_IN_USE;
// Message 对象中的信息都不再有意义，在放入缓存池前直接清空。
what = 0;
arg1 = 0;
arg2 = 0;
obj = null;
replyTo = null;
sendingUid = -1;
when = 0;
target = null;
callback = null;
data = null;
synchronized (sPoolSync) {
// 缓存池中只缓存一定数量的 Message 对象，默认是 50 个。
if (sPoolSize < MAX_POOL_SIZE) {
// 把对象放在缓存池的链表首部。
next = sPool;
sPool = this;
// 及时更新缓存池大小。
sPoolSize++;
}
}
}
3.2 创建消息队列
消息队列的创建对消息传递至关重要，它决定了消息在传递过程中的存取方式。但是线程在默认情况下是没有消息队列的，也无法在其内部进行消息循环。如果想为线程开启消息循环就需要使用到Looper类，它可以为关联的线程创建消息队列并开启消息循环，创建消息队列的方式是调用prepare()接口：
/**
-
Class used to run a message loop for a thread. Threads by default do
-
not have a message loop associated with them; to create one, call
-
{@link #prepare} in the thread that is to run the loop, and then
-
{@link #loop} to have it process messages until the loop is stopped.
*/
public final class Looper {
// 省略无关代码
// sThreadLocal.get() will return null unless you’ve called prepare().
static final ThreadLocal sThreadLocal = new ThreadLocal();
// 内部的消息队列和关联的线程
final MessageQueue mQueue;
final Thread mThread;
// 省略无关代码
/** Initialize the current thread as a looper.
-
This gives you a chance to create handlers that then reference
-
this looper, before actually starting the loop. Be sure to call
-
{@link #loop()} after calling this method, and end it by calling
-
{@link #quit()}.
*/
public static void prepare() {
// 创建可退出的消息循环，主线程的消息循环是不可退出的。
prepare(true);
}
private static void prepare(boolean quitAllowed) {
// 如果当前线程已经有了 Looper 对象就直接抛出异常，
// 因为一个线程只能有一个消息队列。
if (sThreadLocal.get() != null) {
throw new RuntimeException(“Only one Looper may be created per thread”);
}
// 创建 Looper 对象并和线程关联。
sThreadLocal.set(new Looper(quitAllowed));
}
// 私有构造函数，创建消息队列并获取当前线程对象。
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
可以看到Looper.prepare()只是在内部创建了一个MessageQueue对象并和当前线程关联起来，同时还保证了每个线程只能有一个消息队列。
很显然MessageQueue就是用来存储消息对象的结构了，看下它的声明：
/**
-
Low-level class holding the list of messages to be dispatched by a
-
{@link Looper}. Messages are not added directly to a MessageQueue,
-
but rather through {@link Handler} objects associated with the Looper.
-
You can retrieve the MessageQueue for the current thread with
-
{@link Looper#myQueue() Looper.myQueue()}.
*/
public final class MessageQueue { … }
MessageQueue是一个持有消息对象列表的类，而这些消息对象通过和Looper关联的Handler添加并最终由Looper进行分发，其中有个关键信息需要引起我们的格外关注：list of messages，这是不是告诉我们虽然这个类的名字是queue但是其内部并不是队列而是列表呢？确实如此，MessageQueue的内部是使用单向链表的方法进行存取的，这点在后面解析Message的存取过程中会看到，在这里就不详细讲述了。
3.3 开启消息循环
“消息队列”创建完成了，是不是就可以直接向其中添加消息对象了呢？还不到时候，还需要先开启消息循环，来监听消息队列的情况，这时需要使用Looper.loop()接口：
/**
-
Run the message queue in this thread. Be sure to call
-
{@link #quit()} to end the 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.”);
}
// 获取当前线程的消息队列。
final MessageQueue queue = me.mQueue;
// 省略无关代码
// 开启一个无限循环来监听消息队列的情况
for (;😉 {
// 获取消息队列中的消息对象，如果没有消息对象就阻塞等待。
Message msg = queue.next(); // might block
if (msg == null) {
// 消息队列正在退出时就终止监听并退出循环
return;
}
// 省略无关代码
try {
// 分发消息，把消息发送合适的处理对象。
msg.target.dispatchMessage(msg);
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
// 省略无关代码
// 回收消息对象，放入消息缓存池中以待后续复用。
msg.recycleUnchecked();
}
}
这段代码本身比较复杂，我省略了其中和核心逻辑无关的部分代码，以方便大家阅读和理解，其核心逻辑就是利用一个“无限循环”来监听消息队列，当发现有可用消息就取出并分发处理，如果没有就一直等待。
3.4 发送和存储消息
“消息队列”已经创建完成，“消息循环”也已经开启，终于可用发送消息了。
要发送消息，就要使用到Handler类了，其中的send和post系列方法都可以进行“消息的发送”，核心方法都是一样的，在这里就以post方法来讲解下发送消息的过程：
/**
-
Causes the Runnable r to be added to the message queue.
-
The runnable will be run on the thread to which this handler is
-
attached.
-
@param r The Runnable that will be executed.
-
@return Returns true if the Runnable was successfully placed in to the
-
message queue. Returns false on failure, usually because the -
looper processing the message queue is exiting.
*/
public final boolean post(Runnable r) {
return sendMessageDelayed(getPostMessage®, 0);
}
private static Message getPostMessage(Runnable r) {
// 把 Runnable 对象封装成 Message 并设置 callback，
// 这个 callback 会在后面消息的分发处理中起到作用。
Message m = Message.obtain();
m.callback = r;
return m;
}
public final boolean sendMessageDelayed(Message msg, long delayMillis) {
if (delayMillis < 0) {
delayMillis = 0;
}
// 把延迟时间转换为绝对时间，方便后续执行。
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
// 消息队列，即通过 Looper.prepare() 创建的消息队列。
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);
}
通过一系列的调用过程，Handler最终会通过 MessageQueue.enqueueMessage()把消息存储到消息队列中，MessageQueue内部又是如何存储这个发送过来的消息对象的呢？
boolean enqueueMessage(Message msg, long when) {
// 消息对象的目标是 null 时直接抛出异常，因为这意味这个消息无法进行分发处理，
// 是不合法的消息对象。
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;
}
学习交流
如果你觉得自己学习效率低，缺乏正确的指导，可以加入资源丰富，学习氛围浓厚的技术圈一起学习交流吧！
群内有许多来自一线的技术大牛，也有在小厂或外包公司奋斗的码农，我们致力打造一个平等，高质量的Android交流圈子，不一定能短期就让每个人的技术突飞猛进，但从长远来说，眼光，格局，长远发展的方向才是最重要的。
35岁中年危机大多是因为被短期的利益牵着走，过早压榨掉了价值，如果能一开始就树立一个正确的长远的职业规划。35岁后的你只会比周围的人更值钱。
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数初中级安卓工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Android移动开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Android）
片转存中…(img-chJSN5fh-1711012704070)]
群内有许多来自一线的技术大牛，也有在小厂或外包公司奋斗的码农，我们致力打造一个平等，高质量的Android交流圈子，不一定能短期就让每个人的技术突飞猛进，但从长远来说，眼光，格局，长远发展的方向才是最重要的。
35岁中年危机大多是因为被短期的利益牵着走，过早压榨掉了价值，如果能一开始就树立一个正确的长远的职业规划。35岁后的你只会比周围的人更值钱。
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数初中级安卓工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Android移动开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-TmjEctM4-1711012704071)]
[外链图片转存中…(img-YiVcs5rn-1711012704071)]
[外链图片转存中…(img-BR7mfAoo-1711012704072)]
[外链图片转存中…(img-dDj3xmnF-1711012704072)]
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Android）
[外链图片转存中…(img-KZ8xRW7M-1711012704072)]
879
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
