Android-消息机制（Handler机制）浅析
简介
Android消息机制主要就是指Handler的运行机制；
借用网络的图片
图解：
1.以Handler的sendMessage方法为例，当发送一个消息后，会将此消息加入消息队列MessageQueue中。
2.Looper负责去遍历消息队列并且将队列中的消息分发给对应的Handler进行处理。
3.在Handler的handleMessage方法中处理该消息，这就完成了一个消息的发送和处理过程。
这里从图中可以看到参与消息处理有四个对象，它们分别是 Handler, Message, MessageQueue，Looper。
*ThreadLocal 定义
ThreadLocal 是一个线程内部的数据存储类，通过它可以在指定的线程中存储数据，数据存储以后，只有再指定线程中可以获取到存储的数据，对于其他线程来说则无法获取到数据。
源码探索
App启动
ActivityThread 类
ActivityThread类中mian方法中，注意看Looper.prepareMainLooper();的调用，会为当前这个App创建出全局唯一的Looper对象；
package android.app;
......
public final class ActivityThread extends ClientTransactionHandler {
......
......
public static void main(String[] args) {
......
......
//创建出App全局唯一的Looper对象
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");
}
}
Looper 类
当ActivityThread类的main方法中调用了Looper.prepareMainLooper的时候，会先创建出当前主线程唯一的Looper对象，并调用ThreadLocal的set方法将这个Looper对象传了进去，在创建Looper对象的时候，构造方法中又创建了当前这个Looper中的唯一的消息队列MessageQueue和获取到当前线程保存到Looper中唯一的mThread线程对象中；
package android.os;
......
public final class Looper {
......
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
......
final MessageQueue mQueue;
final Thread mThread;
......
//构造方法
//在这个构造方法中，有创建了当前Looper唯一的消息队列MessageQueue和将当前线程复制到了全局的mThread线程对象中
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
......
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
//这里为我们创建了全局唯一的Looper对象
sThreadLocal.set(new Looper(quitAllowed));
}
......
}
ThreadLocal类
接着上面，创建主线程唯一的Looper对象之后调用了ThreadLocal类中的这个set方法，将Looper对象传了进来；
传入进来的时候，因为当前是主线程第一次创建Looper对象，并set进来，所以这类获取ThreadLocalMap的时候是个null，然后走到下面的else当中，去给当前线程Thread创建ThreadLocalMap并保存到threadLocals 这个全局变量中；
ThreadLocalMap是键值对的方式保存，key是当前线程，value是当前线程的Looper对象；
public class ThreadLocal<T> {
......
public void set(T value) {
//获取到当前线程
Thread t = Thread.currentThread();
//通过当前线程去获取ThreadLocalMap对象
//这里的ThreadLocalMap拿的是当前这个Thread线程中的变量ThreadLocalMap 对象 而一路跟进来，这里的线程肯定是主线程吧
//这里是第一次进来，所以当前这个主线程肯定是没有ThreadLocalMap对象
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
//所以当前线程会走入这个创建ThreadLocalMap的方法中，并且保存到当前这个线程中的threadLocals变量中
createMap(t, value);
}
......
void createMap(Thread t, T firstValue) {
//创建ThreadLocalMap并赋值保存到当前线程的threadLocals 对象中；
//这个时候全局唯一的主线程中的这个threadLocals 对象就有了吧
t.threadLocals = new ThreadLocalMap(this, firstValue);
}
......
}
流程图
小结
相信大家看完这里，就能明白ActivityThread类main方法中会给我们创建出全局唯一的主线程的Looper对象，和Looper对象中会给我们创建出当前主线程Looper对象全局唯一的消息队列以及赋值了当前线程，也可以说是当前主线程的消息队列；
主线程中创建Handler
private Handler handler = new Handler(){
@Override
public void handleMessage(@NonNull Message msg) {
super.handleMessage(msg);
}
};
我们跟进这个Handler类里面去看看
创建Handler的时候，通过Looper.myLooper去获取了全局唯一主线程的Looper对象；这里获取到的Looper对象是不为空的，为什么不为空，请往下翻，下面有解释；
然后将获取的主线程Looper的消息队列变量赋值到了当前这个Handler的消息队列变量上；赋值回调Callback；
也就是说当前这个Handler是有个消息队列的，这个消息队列就是主线程唯一的消息队列；
package android.os;
public class Handler {
public Handler() {
this(null, false);
}
public Handler(@Nullable Callback callback, boolean async) {
......
//这类是获取当前线程（因为是主线程创建的Handler，所以这里是获取了全局唯一的主线程Looper对象）的Looper对象
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
//拿到Looper对象的消息队列，赋值到了当前Handler的消息队列变量上面；
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
}
Looper类中的myLooper方法
这方法中调用了ThreadLocal的get方法
......
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
......
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
ThreadLocal的get方法
可以看到这里是获取了一遍当前线程；
通过当前线程去获取了ThreadLocalMap 对象；
记得ActivityThread类的main方法调用吧？
主线程的ThreadLocalMap 对象是存在了吧？已经创建并赋值到了当前线程的threadLocals变量上面了吧
public T get() {
//获取当前线程，因为是在主线程中创建的Handler对象；
//所以这类是拿到主线程
Thread t = Thread.currentThread();
//通过主线程获取到主线程的ThreadLocalMap对象
//因为主线程的ThreadLocalMap对象已经在ActivityThread的main方法中创建了，所以这里不为空
ThreadLocalMap map = getMap(t);
if (map != null) {
//进入到这里
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
流程图
发送消息handler.sendMessage(msg);
我们跟进Handler中的sendMessage方法中去
注意：sendMessage这个方法最终调用的是sendMessageDelayed这个延时的方法，但是默认传了个0秒延时；
然后调入到sendMessageAtTime这个方法中，将全局唯一的消息队列赋值到了局部的消息队列变量中，然后调用enqueueMessage这个方法；
enqueueMessage方法中：
1、将当前Handler本身保存到了传入进来的Message的target变量上面，这时候这个message就持有了当前这个Handler了；
2、最后调用的是消息队列的enqueueMessage方法，将持有当前Handler引用的消息队列，以及更新的时间传入到了这个方法中
接着往下看↓
package android.os;
public class Handler {
public final boolean sendMessage(@NonNull Message msg) {
return sendMessageDelayed(msg, 0);
}
public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
public boolean sendMessageAtTime(@NonNull 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);
}
private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
long uptimeMillis) {
//将当前Handler本身保存到了传入进来的Message的target变量上面，这时候这个message就持有了当前这个Handler了
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
//最后调用的是消息队列的enqueueMessage方法，将持有当前Handler引用的消息队列，以及更新的时间传入到了这个方法中
return queue.enqueueMessage(msg, uptimeMillis);
}
}
我们来看看MessageQueue里面的enqueueMessage方法
进来一条消息消息赋值到全局的Message上；
这方法中会有唤醒操作，继续往后看；
Message中有个对象池的概念：Message类使用了一个链表来实现对象池，最大支持50条消息对象；
Message类中有一个常量：private static final int MAX_POOL_SIZE = 50; 这是对象池中支持的最大消息对象；
里面有一个全局静态的sPoolSize指针，这个对象永远都是指向的是当前的第一个；
public final class MessageQueue {
......
Message mMessages;
......
boolean enqueueMessage(Message msg, long when) {
......
......
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) {
msg.next = p;
//将持有Handler引用的消息Message赋值到了全局变量中
mMessages = msg;
needWake = mBlocked;
} else {
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;
}
}
流程图
处理消息
我们回到App启动的ActivityThread 类中的main方法中
Looper.loop()： 这类调用了Looper.loop()方法，这个方法是开启当前全局唯一的主线程Looper对象的消息循环；
往下看，我们跟进这个Looper.loop方法中去，往下看↓
package android.app;
......
public final class ActivityThread extends ClientTransactionHandler {
......
......
public static void main(String[] args) {
......
......
//创建出App全局唯一的Looper对象
Looper.prepareMainLooper();
......
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
}
Looper类中的loop方法
这类我们只看主要的调用了，省略掉其他的一些判断和啥的…
1、myLooper方法我们上面已经解释了吧？就是获取当前的Looper对象；
2、拿到这个Looper对象中的消息队列；
3、无限循环，去消息队列中取消息，然后调用msg.target.dispatchMessage(msg);去分发消息；
是否还记得target这个值？？？
这个是当前这个消息Message对象中存放的Handler引用；
这里就是说，最后通过调用当前handler吧消息通过dispatchMessage方法分发出去了。
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.");
}
//获取到Looper对象中的消息队列
final MessageQueue queue = me.mQueue;
//开启无限循环
for (;;) {
//从消息队列中取出下一条消息
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
......
......
//调用msg对象中的handler的dispatchMessage方法把消息分发出去；
msg.target.dispatchMessage(msg);
}
}
来看看这个Handler的dispatchMessage方法
Loop方法中，无限循环，把消息传入到这个方法中；
判断了下消息中是否有回调，如果没有，调用handleCallback方法；
如果有回调，在判断了下当前Handler中是否有回调接口，如果有的话，直接用Handler的回调接口，把消息分发出去，如果没有的话，调用handleMessage方法，把消息分发出去；
还记得handleMessage这个方法不？我们在创建Handler的时候，会去重写的handleMessage方法，用来处理消息的；
public void dispatchMessage(@NonNull Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
//创建handler 重写的handleMessage方法
handleMessage(msg);
}
}
private static void handleCallback(Message message) {
message.callback.run();
}
public void handleMessage(@NonNull Message msg) {
}
图解
消息阻塞和延时
Looper 的阻塞主要是靠 MessageQueue 来实现的，在next()@MessageQuese 进行阻塞，在 enqueueMessage()@MessageQueue 进行唤醒。主要依赖 native 层的 Looper 依靠 epoll 机制进行的。
消息阻塞
来看看这个消息队列MessageQueue的next方法
nativePollOnce(ptr, nextPollTimeoutMillis) 这是调入到这个方法，注意看这类是一个native层的方法…阻塞在这个方法上面，等待唤醒；
native层中也是一个死循环；
被唤醒之后，才会接着下面的代码继续往下走；
阻塞和延时，主要是next（）中nativePollOnce(ptr, nextPollTimeoutMillis)调用naive方法操作管道，由nextPollTimeoutMillis决定是否需要阻塞nextPollTimeoutMillis为0的时候表示不阻塞，为-1的时候表示一直阻塞直到被唤醒，其他时间表示延时。
那为什么主线程这类阻塞了，而没造成app的卡死ANR？
有人的解释是：native层会帮我们做一些资源的释放；
public final class MessageQueue {
......
private native void nativePollOnce(long ptr, int timeoutMillis);
......
Message next() {
......
......
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
//消息的阻塞 nextPollTimeoutMillis时间
nativePollOnce(ptr, nextPollTimeoutMillis);
......
......
......
}
}
唤醒
唤醒也同样是在消息队列MessageQueue中，这是在enqueueMessage方法
同样是调用的native蹭的nativeWake方法做唤醒操作
private native static void nativeWake(long ptr);
boolean enqueueMessage(Message msg, long when) {
......
......
synchronized (this) {
......
......
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
对Handler中的Native层调用需要了解的请移步
转载-Handler消息机制(native层)
阻塞、唤醒的流程图
问题
为什么不能在子线程中更新UI,根本原因是什么?
mThread是UI线程，这里会检查当前线程是不是UI线程。那么为什么onCreate里面没有进行这个检查呢。这个问题原因出现在Activity的生命周期中，在onCreate方法中，UI处于创建过程，对用户来说界面还不可视，直到onStart方法后界面可视了，再到onResume方法后界面可以交互。从某种程度来讲，在onCreate方法中不能算是更新UI，只能说是配置UI，或者是设置UI的属性。这个时候不会调用到ViewRootImpl.checkThread()，因为ViewRootImpl没被创建。而在onResume方法后，ViewRootImpl才被创建。这个时候去交互界面才算是更新UI。
setContentView只是建立了View树，并没有进行渲染工作（其实真正的渲染工作是在
onResume之后）。也正是建立了View树，因此我们可以通过findViewById（）来获取到View对象，但是由于并没有进行渲染视图的工作，也就是没有执行ViewRootImpl.performTransversal。同样View中也不会执行onMeasure（），如果在onResume（）方法里直接获取View.getHeight（）/View.getWidth（）得到的结果总是0。
Handler内存泄露产生的原因？
Handler的handleMessage方法中（或者run方法）处理消息，如果这个时候一个来了一条延时消息，会一直保存在主线程的消息队列里面，并且会影响系统对Activity的回收，造成内存泄露
感谢各位童鞋观看到最后，一起共勉加油，大神勿喷，谢谢~~
93
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
