1.Handler.java
Android Handler机制源码浅析(下) ：https://blog.csdn.net/XCF95319605/article/details/81088119
Handler的主要作用是消息的发送和接收（处理消息），handler内部是通过一系列的post方法和send方法来进行消息的发送，不过post方法都是通过间接调用send方法来完成的。
Handler中的post方法列表
- post(Runnable r)
- postAtTime(Runnable r, long uptimeMillis)
- postAtTime(Runnable r, Object token, long uptimeMillis)
- postDelayed(Runnable r, long delayMillis)
- postAtFrontOfQueue(Runnable r)
Handler中send方法列表
- sendMessage(Message msg)
- sendEmptyMessage(int what)
- sendEmptyMessageDelayed(int what, long delayMillis)
- sendEmptyMessageAtTime(int what, long uptimeMillis)
- sendMessageDelayed(Message msg, long delayMillis)
- sendMessageAtTime(Message msg, long uptimeMillis)
- sendMessageAtFrontOfQueue(Message msg)
- sendMonitorMessage(Message msg, long delayMillis, long executiontimeout, long pendingtimeout, String msgLoggerName)
(1) 随便找一个post方法和send方法来进行分析，我们先来看看post方法：
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
在这里我们发现post方法被调用以后就直接调用了send方法中的sendMessageDelayed方法来进行消息的发送，其他post方法也是类似的，只是传入的参数和调用了不同的send方法而已，有兴趣可以去看源码。
接下来看一下sendMessageAtTime，因为sendMessage会间接调用到这个方法，所以就对这个方法进行分析：
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); //调用enqueueMessage方法
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis); //将msg方法消息队列中
}
其实我们平时是调用sendMessage方法，但是sendMessage会直接调用sendMessageDelayed方法，而sendMessageDelayed又会直接调用到sendMessageAtTime方法，所以就忽略掉前面部分，直接从sendMessageAtTime开始分析，首先sendMessageAtTime被调用时，会先获取到当前的MessageQueue，进行判空，然后调用enqueueMessage方法，enqueueMessage最后将消息插入到消息队列，至此完成了一次简单的Message的发送流程。
(2) 接下来我们来分析一下Handler处理消息的过程：
handler是通过dispatchMessage方法来处理消息的，而dispatchMessage方法是被在Looper中被调用的，我们首先来看一下dispatchMessage的源码实现，然后再去分析Looper中对dispatchMessage的调用，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的源码很简单，第一步：先检查msg的callback（Runnable）是否为空，若不为空，则交给handlerCallback处理，我们来看看handlerCallback源码做了什么：
private static void handleCallback(Message message) {
message.callback.run();
}
handlerCallback的源码也很简单，就是开启传进来的message的run方法，那么问题来了，为什么有run方法，相信从前面的post方法你已经看出来了，这个run方法就是前面通过post发送消息时传递进来的那个Runnable实现类的run方法，好了，第一个if语句已经剖析清楚了。
接下来我们看看第二个if语句，检查mCallback是否为空，不为空则将消息交给handlerMessage来处理，首先我们来看看mCallback在源码中的定义：
final Callback mCallback; //Callback类我们再看看Callback的定义：
/**
* Callback interface you can use when instantiating a Handler to avoid
* having to implement your own subclass of Handler.
*
* @param msg A {@link android.os.Message Message} object
* @return True if no further handling is desired
*/
public interface Callback {
public boolean handleMessage(Message msg);
}
那么这个mCallback又是在哪初始化的呢？还是看源码：
public Handler(Callback callback) {
this(callback, false);
}
public Handler(Callback callback, boolean async) {
…
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;
}
原来是当我们采用传入一个callback来获取一个handler实例的时候，重写里面的handleMessage来处理具体的消息，在Callback的接口的上面注释以及说明了：在实例化处理程序时可以使用的回调接口，以避免实现自己的Handler子类。
最后程序将会把消息交给我们重写的handleMessage来进行处理，至此，整个Handler的消息处理过程分析完毕。
2.Looper.java
Looper在Android消息机制中就专门负责循环的去监听消息，监听哪儿的消息呢？对就是MessageQueue里面的消息，当MessageQueue里面有消息的时候Looper就会去将消息取出来给Handler进行处理，首先我们来分析一下Looper 的构造方法：
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
很简单，构造方法就做了两件事，首先是创建一个消息队列，然后将当前Looper所在的线程进行了保存操作。
Handler正常工作是离不开Looper的，那么为什么我们平时在UI线程使用Handler的时候却没有手动的去创建Looper呢？那是因为Android系统默认帮我们在主线程创建了一个Looper所以并不需要我们去手动的创建Looper对象，以下源码是在ActivityThread中的main方法中，Android系统为我们创建Looper的过程，已经删减掉和Looper无关的代码：
public static void main(String[] args) {
...
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
...
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
接下来我们来分析一下UI线程获取到Looper的过程，在main方法中首先调用了Looper的prepareMainLooper()方法，该方法是用来实例化Looper对象的，跟着源码的调用轨迹来看一下调用过程：
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();//调用myLooper()获取Looper对象
}
}
返回与当前线程相关联的Looper对象，如果调用线程没有与Looper关联，则返回null。
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
最后调用Looper.loop();来开启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;
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
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
final long traceTag = me.mTraceTag;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
final long end;
try {
msg.target.dispatchMessage(msg);
end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (slowDispatchThresholdMs > 0) {
final long time = end - start;
if (time > slowDispatchThresholdMs) {
Slog.w(TAG, "Dispatch took " + time + "ms on "
+ Thread.currentThread().getName() + ", h=" +
msg.target + " cb=" + msg.callback + " msg=" + msg.what);
}
}
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(;;)代码块，里面是一个死循环，而跳出该循环的唯一条件是msg为空，就是当MessageQueue的next方法返回了null。如果next方法返回了新的消息，looper就会处理这条消息：msg.target.dispatchMessage(msg);，这里的msg.target指的是发送这条消息的对象，这样，相当于消息最后又回到了Handler本身去处理消息。至此整个Looper的工作流程就基本分析完毕了，就是通过Looper的构造器创建一个消息队列，然后通过prepareMainLooper在当前线程实例化Looper对象，最后通过loop方法来开启循环，处理相应的消息，只是所谓的处理是把消息对象返回给发送这条消息的Handler对象。
Looper除了提供prepareMainLooper让UI线程实例化Looper以外，还提供了prepare()方法来方便我们在任意线程实例化Looper对象，使用方式可参考上面main方法中，都是先通过prepare()来实例化对象，然后通过loop()方法来开启循环。
至此，整个Looper的循环处理过程就分析完毕了。
Android Handler机制源码浅析(下) ：https://blog.csdn.net/XCF95319605/article/details/81088119
764
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
