目录
二、Handler对象 在新启动的子线程发送消息（源码跟踪）
三、在主线程中，回调 handleMessage 方法的流程是怎样的呢？
③. MessageQueue （它是一个消息队列）
系列文章
Handler异步消息传递机制（一）Handler常用基本用法
Handler异步消息传递机制（二）在子线程中创建Handler
Handler异步消息传递机制（三）在主线程、子线程中创建Handler，源码（Android 9.0）解析
Handler异步消息传递机制（四）Handler发送消息流程，源码（Android 9.0）解析
一、前言
上篇文章我们从源码角度分析了如何在主线程、子线程创建Handler对象。详细可参考：Handler异步消息传递机制（三）在主线程、子线程中创建Handler，源码（Android 9.0）彻底解析
那么创建Handler之后，如何发送消息呢？这个流程相信大家也已经非常熟悉了，我们继续以文章 Handler异步消息传递机制（一）Handler常用实现方式 的demo为例，然后进行源码跟踪解析！
二、Handler对象 在新启动的子线程发送消息（源码跟踪）
下面是 Handler对象：在新启动的子线程发送消息 的代码：
public class DownLoadAppFile {
public void download(String urlPath, Handler handler, ProgressBar pb) {
try {
//下载apk的代码，这里用线程睡眠模拟
Thread.currentThread().sleep(3*1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
Message msg = Message.obtain();
msg.what =1;//成功
//msg.what =2;//失败
handler.sendMessage(msg);//发送消息
}
}Handler 到底是把 Message 发送到哪里去了呢？
为什么之后又可以在 Handler 的 handleMessage 方法中重新得到这条Message呢？
接下来我们来看一下发送消息的源码：
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}它里面调用了sendMessageDelayed方法，
往下追踪
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}我们可以看到 sendMessageDelayed 方法，其中 msg 参数就是我们发送的 Message 对象，
而 delayMillis 参数则表示延迟发送消息的时间（毫秒），这里默认传入的为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);
}我们可以看到 sendMessageAtTime 方法同样接收两个参数，其中msg参数就是我们发送的 Message 对象，
而 uptimeMillis 参数则表示发送消息的时间，SystemClock.uptimeMillis() + delayMillis 即它的值等于自系统开机到当前时间的毫秒数再加上延迟时间。
然后对 MessageQueue 对象 queue 进行了赋值，这个 MessageQueue 又是什么东西呢？
学过java基础的可能会马上想到Queue，基本上一个队列就是一个先入先出（FIFO）的数据结构。
同样在这里 MessageQueue 直译过来就是 消息队列 的意思，用于将所有收到的消息以队列的形式进行排列，并提供入队和出队的方法。
那么 enqueueMessage 方法就是入队的方法了，我们来看下这个方法的源码：
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}msg.target = this; 即msg.target 赋值为 this，也就是把当前所在类 Handler，作为 msg 的 target 属性。
然后将这三个参数都传递到 MessageQueue 的 enqueueMessage 方法中，
也就是说handler发出的消息，最终会保存到消息队列中去。
调用 sendMessage 方法其实最后是调用了类 MessageQueueen 消息队列的 enqueueMessage 入队方法。
那么有了 MessageQueue 消息队列的 enqueueMessage 入队方法，它必然有相对应的出队方法。
Handler 对象在新启动的子线程发送消息以后，接下来在主线程中，Handler类处理消息的方法 handleMessage 被自动回调。
三、在主线程中，回调 handleMessage 方法的流程是怎样的呢？
那么接下来在主线程中，回调 handleMessage 方法的流程是怎样的呢？
Android的主线程就是 ActivityThread，主线程的入口方法为main，我们继续来看一下 ActivityThread 类中main方法的源代码：
public static void main(String[] args) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
// CloseGuard defaults to true and can be quite spammy. We
// disable it here, but selectively enable it later (via
// StrictMode) on debug builds, but using DropBox, not logs.
CloseGuard.setEnabled(false);
Environment.initForCurrentUser();
// Set the reporter for event logging in libcore
EventLogger.setReporter(new EventLoggingReporter());
// Make sure TrustedCertificateStore looks in the right place for CA certificates
final File configDir = Environment.getUserConfigDirectory(UserHandle.myUserId());
TrustedCertificateStore.setDefaultUserDirectory(configDir);
Process.setArgV0("<pre-initialized>");
Looper.prepareMainLooper();
// Find the value for {@link #PROC_START_SEQ_IDENT} if provided on the command line.
// It will be in the format "seq=114"
long startSeq = 0;
if (args != null) {
for (int i = args.length - 1; i >= 0; --i) {
if (args[i] != null && args[i].startsWith(PROC_START_SEQ_IDENT)) {
startSeq = Long.parseLong(
args[i].substring(PROC_START_SEQ_IDENT.length()));
}
}
}
ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
第47行调用了 Looper.loop() 方法，这个方法内部执行了消息循环，我们来看下它的源码：
public static void loop() {
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;
// 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();
// Allow overriding a threshold with a system prop. e.g.
// adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'
final int thresholdOverride =
SystemProperties.getInt("log.looper."
+ Process.myUid() + "."
+ Thread.currentThread().getName()
+ ".slow", 0);
boolean slowDeliveryDetected = false;
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
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long traceTag = me.mTraceTag;
long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;
if (thresholdOverride > 0) {
slowDispatchThresholdMs = thresholdOverride;
slowDeliveryThresholdMs = thresholdOverride;
}
final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0) && (msg.when > 0);
final boolean logSlowDispatch = (slowDispatchThresholdMs > 0);
final boolean needStartTime = logSlowDelivery || logSlowDispatch;
final boolean needEndTime = logSlowDispatch;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;
final long dispatchEnd;
try {
msg.target.dispatchMessage(msg);
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (logSlowDelivery) {
if (slowDeliveryDetected) {
if ((dispatchStart - msg.when) <= 10) {
Slog.w(TAG, "Drained");
slowDeliveryDetected = false;
}
} else {
if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, "delivery",
msg)) {
// Once we write a slow delivery log, suppress until the queue drains.
slowDeliveryDetected = true;
}
}
}
if (logSlowDispatch) {
showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", 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();
}
}我们可以看到前面几行代码，首先对 Looper、MessageQueue 对象进行了赋值，
然后第23行进入了一个死循环for( ; ; ){ }，然后不断地调用的 MessageQueue 的 next 方法，
Message msg = queue.next() 很明显这个 next 方法就是消息队列的出队方法。
接下来你会发现第57行执行了 msg.target.dispatchMessage(msg);
其中 msg.targe t就是指的 Handler 对象，你回看一下上面enqueueMessage()方法就可以看出来。
接下来当然就要看一看 Handler 中 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);
}
}在第8行进行判断，如果 mCallback 不为空，则调用 mCallback 的 handleMessage 方法，
否则直接调用Handler的handleMessage方法，并将消息对象作为参数传递过去。
这样我相信大家就都明白了为什么 handleMessage 方法中可以获取到之前发送的消息了吧！
四、总结说
1、主要由四个部分组成
①. Message （主要用于携带消息）
在线程之间传递，可在内部携带少量信息，用于不同线程之间交换数据
可以使用what、arg1、arg2字段携带整型数据
obj字段携带Object对象
②. Handler （主要用于发送和处理消息）
1、如果看过Handler源码，你会知道 Handler 构造器，
做了 Looper 对象是否为空的判定，
也就是创建Handler对象之前，必须拥有不为null的Looper对象。
所以子线程创建Handler后会报错，它需要调用 prepare()方法。
2、我们平时可以直接在主线程中使用Handler，
那是因为在应用程序启动时，在入口的main方法中已经默认为我们创建好了Looper。
主线程中内部调用了Looper的prepareMainLooper方法，
而prepareMainLooper方法里面调用了Looper的prepare() 方法，所以不会报错。
3、sendMessage方法用来发送消息，最终会回到handleMessage方法进行处理。
③. MessageQueue （它是一个消息队列）
1、先入先出（FIFO）的数据结构。
主要存放所有通过Handler发送的消息，
它们会一直存在于队列中等待被处理
2、每个线程只有一个MessageQueue。
enqueueMessage 入队方法，next 出队方法
④. Looper （它是一个循环器）
调用loop方法后，会不断从MessageQueue 取出待处理的消息，
然后传递到handleMessage进行处理
2、常见用法与源码解读
1、子线程
Handler对象调用 sendMessage 等方法发送消息，源码内部在调用过程中得到 MessageQueue 对象（它是先入先出的队列），
其实最后是调用MessageQueue 消息队列的 enqueueMessage 入队方法，收到的消息以队列的形式进行排列
2、主线程
Android 的主线程就是 ActivityThread，主线程的入口为main方法，main方法内部：
（1）：Looper 调用 prepareMainLooper 静态方法，内部会去调用 prepare 方法（创建 一个Looper对象），
方法内部具体： 判读是否有Looper对象？ 有，提示 “每个线程只能创建一个 Looper对象”；没有，创建一个新的Looper设置进去
（2）：Looper调用 loop 方法，loop方法内部：
首先调用 myLooper 方法，去取一个Looper对象，
如果Looper对象为空，会抛出一个异常，提示没有Looper对象；
如果Looper不为空，继续执行得到 MessageQueueen 消息队列，然后进行 for循环操作，
for循环里面是 MessageQueueen 对象调用 next 出队方法，得到一个个Message 消息，调用dispatchMessage发送消息，
最后通过回调 handleMessage 方法并把 Message 消息依次传递过去。
这里采用网上的一张图，个人感觉图片概括得很好，就没必要再去造同样的轮子了，在新窗口打开可浏览大图
不错博文可参考：
Android异步消息处理机制完全解析，带你从源码的角度彻底理解_郭霖的专栏-CSDN博客_android 异步消息
Android进阶——Android消息机制之Looper、Handler、MessageQueen_点击置顶文章查看博客目录（全站式导航）-CSDN博客_handler looper
1284
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
