前方高能预警，大量源码来袭，不想仔细看源码的同学可直接看本文末的Handler流程图。本文是基于10.0源码分析。
说到Handler相信大家都会说是android中的用来进行消息传递的，主要用于异步消息的处理......相信做android的同学都知道。
那么Handler是如何工作的呢，相信大家也都能说出来，主要是Handler发送Message，最终把Message放入MessageQueue（消息队列）中，Looper按照先进先出的原则从MessageQueue中取出Message最终交给Handler进行处理。过程是对的，那么这一系列的过程具体是怎么完成的呢，中间发生了什么呢，下面就带领大家一起来从源码中找出答案。
Handler用起来非常简单,下面这段代码就可以完成简单的使用:
private Handler mHandler = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(@NonNull Message msg) {
switch (msg.what) {
case 0: {
}
default:
break;
}
return false;
}
});
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mHandler.sendEmptyMessage(0);
}
先分析Handler的构造过程
public Handler(@Nullable Callback callback, boolean async) {
...省略若干...
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
从上面代码中发现会得到一个mLooper,如果mLooper为空则直接抛异常
throw new RuntimeException(
"Can't create handler inside thread " + Thread.currentThread()
+ " that has not called Looper.prepare()");
那么mLooper是哪来的呢，我们在使用Handler的过程中也没有初始化过Looper啊。别着急让我们看看Looper，追踪代码发现mLooper是从Looper中的sThreadLocal中获取的
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
ThreadLocal是一个关于创建线程局部变量的类、而使用ThreadLocal创建的变量只能被当前线程访问，其他线程则无法访问和修改。 继续追踪源码我们会发现ActivityThread的main方法中有以下代码:
public static void main(String[] args) {
...省略若干代码...
Looper.prepareMainLooper();
...省略若干代码...
Looper.loop();
}
看到这恍然大悟，原来在程序启动的时候ActivityThread已经为我们初始化了一个主线程Looper放入到ThreadLocal中并已经执行了Looper.loop()方法，所以我们用Handler的时候直接初始化发送消息即可。
以上是Handler初始化时和初始化之前做的事情，那么Handler发送消息时又发生了什么呢？跟踪源码我们发现无论是send一个message还是post一个message最终都会走到下面方法中，至于他俩有什么区别后面再说。
public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
继续追踪发现最终走到enqueueMessage方法,
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
long uptimeMillis) {
msg.target = this;
msg.workSourceUid = ThreadLocalWorkSource.getUid();
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
里面会调用queue.enqueueMessage方法，而queue则是Handler初始化过程中渠道的Looper中的MessageQueue,接着看下去
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;
}
msg.markInUse();
msg.when = when;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {
// New head, wake up the event queue if 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 (;;) {
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);
}
}
return true;
}
这个方法的主要作用就是把消息放到消息队列中，到这里Handler发送消息这一块就分析完了。
what？后面呢，Handler怎么取消息的？
别着急，让我们往回看，还记的ActivityThread中直接实例化了main Looper并调用了相关方法loop(),loop()方法中就一直在循环的取消息，当有消息进入时就会把消息取出来调用该消息对应的target的dispatchMessage(msg)方法，代码如下
public static void loop() {
...省略若干代码...
// 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);
}
// Make sure the observer won't change while processing a transaction.
final Observer observer = sObserver;
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;
Object token = null;
if (observer != null) {
token = observer.messageDispatchStarting();
}
long origWorkSource = ThreadLocalWorkSource.setUid(msg.workSourceUid);
try {
//主要看这句
msg.target.dispatchMessage(msg);
if (observer != null) {
observer.messageDispatched(token, msg);
}
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} catch (Exception exception) {
if (observer != null) {
observer.dispatchingThrewException(token, msg, exception);
}
throw exception;
} finally {
ThreadLocalWorkSource.restore(origWorkSource);
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
...省略若干代码...
}
}
主要是这句msg.target.dispatchMessage(msg),这个target又是什么呢？还记的Handler为了把消息放入消息队列中最终调用的enqueueMessage方法
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
long uptimeMillis) {
msg.target = this;
msg.workSourceUid = ThreadLocalWorkSource.getUid();
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
从这个方法中可以看到消息中的target就是Handler,看到这一切都串起来了，Handler发送消息到Looper中的MessageQueue中，Looper中的loop()方法一直在循环，取到消息后又交给Handler处理，那么Handler是怎么处理这些消息的呢?
/**
* Handle system messages here.
*/
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
这里分两种情况一个是send的消息，一个是post的消息,方法中会先判断msg.callback是否为空，这其实是在处理post的消息，下面我们看一下post方法干了什么
public final boolean post(@NonNull Runnable r) {
return sendMessageDelayed(getPostMessage(r), 0);
}
这里面有一个getPostMessage方法
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
可以看出这个方法中封装了一个Message,而消息的callback则是一个Runnable，也就是我们post出去的那个Runnable,而Handler在处理消息的时候如果Message的callback不为空则会调用以下方法
private static void handleCallback(Message message) {
message.callback.run();
}
最终调用Runnable中的run方法，这时run会在Handler所在的线程中运行，Handler就是这样完成了线程的消息传递。没错，就是这么简单和神奇。
看完post再看send，如果是send出去的消息，callback是空的则会走到dispatchMessage()方法中的else部分
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
最后是要么调用实例化Handler时传入的mCallback中的handleMessage方法，要么是调用重写的Handler的handleMessage方法，具体是哪个取决于我们的写法。
至此Handler的流程就分析完了，细心地同学已经发现了，Looper中的loop()方法中取消息时是一直执行的，这样难道不会造成ANR么？对此我们完全不用担心，Google工程师早就做了相关优化处理，在这里就不做具体描述了。下面附上我画的简单的Handler功能的流程图
PS:喜欢的同学可以扫码关注我的公众号呦
