前言
·在Android多线程开发场景中Handler消息机制十分常用
·Handler类是Android操作系统为开发者封装的能异步处理消息的辅助类
·本人的水平有限，如果发现错误或不足恳请指正，谢谢
1.要了解消息机制，首先要了解消息处理过程中的相关类。
·Handler : 用来发送和处理消息
·MessageQueue : 消息队列，用于存放Message实体（采用单链表的数据结构）
·Looper : 消息循环，Handler与MessageQueue之间的桥梁。
2.Handler-消息的发送与处理
private Handler mHandler=new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
}
};
这样写可能会造成内存泄漏（非静态内部类），这么问题在后面解决
public Handler(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;
}
这里有部分源代码，内部创建了Looper对象，来看看Looper.myLooper()
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
这里从ThreadLocal里面取出Looper，如果mLooper不存在的情况下，就爆出异常。我们知道，ThreadLocal是线程内部的存储类，可以实现线程隔离，这里不做过多介绍。只要知道ThreadLocal在Handler消息机制扮演的角色是管理每个线程Looper。
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 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);
}
}
发送消息（post最终也会调用sendMessage())使用了延迟发送，sendMessage最终调用了sendMessageDelayed()。先取出消息队列，然后是一个判断，然后我们看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);
}
msg.target = this首先是把target设置为当前的Handler，这个在loop(),方法中会用到，会把消息发送给对应的Handler，然后判断是否是异步的。最后会把这个msg插入到消息队列。Handler就说这么多，我们看MessageQueue
3.MessageQueue-消息队列
MessageQueue最重要的就是enqueue和next这两个方法
首先先看enqueue-插入消息
boolean enqueueMessage(Message msg, long when) {
...
synchronized (this) {
if (p == null || when == 0 || when < p.when) {
msg.next = p;
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;
}
...
}
代码比较多，做一部分删减。这里的主要功能就是找到插入msg的节点，if条件成立，就会插入到链表的头部，如果不成立和根据when来找到链表中合适的节点。进行插入。
然后我们看next-取出消息
Message next() {
/// ....
for (;;) {
//...
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
//...
Message msg = mMessages;
if (msg != null && msg.target == null) {
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// Got a message.
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
return msg;
}
//...
首先我们看这个方法，很重要nativePollOnce方法，这个就是为什么loop死循环为什么不会阻塞线程的关键了。在这个方法，主线程会释放CPU资源进入休眠状态，知道下一个消息到达或者有事物发生，通过Linux的pipe管道写端写入数据来唤醒主线程工作，这里采用的epoll机制就不做过多介绍了（本菜鸡也不会啦，枯了）。然后往下看，mMessage 是单向链表的第一个元素。
我们可以看出上面这段代码有两个判断，我们先看一个第一个判断if(msg !=null && msg.target ==null) ，前一个条件就不做阐述了，后面这个target是什么呢，我们查看message源码的时候就知道了，这其实就是发送消息的hanlder，那么为什么这个值有可能为空呢？我们在messageQueue中看到了postSyncBarrier()这个方法，这个方法是向消息队列插入一个异步消息，并且插入一个屏障并且没有设置target。所以我们在取出队列中消息的时候 要先判断这些异步消息，不然有屏障的存在，哪怕同步消息的执行时间到了，也取不出来。接下来我们看第二个判断，这个判断里面就是根据when来从单向链表中取出需要执行的msg并返回。
然后该Looper上场了
4.Looper-消息循环
他同样也有两个重要的方法prepare和loop
先看prepare
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
这段代码就不做过多解释了，大家都能看懂，prepare方法执行之后会把Looper对象放到对应线程的ThreadLocalMap中，然后在mylooper的时候把线程对应的Looper返回。
下面我们看最重要的方法loop
public static void loop() {
//....
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
// No message indicates that the message queue is quitting.
return;
}
try {
msg.target.dispatchMessage(msg);
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
//....
}
Message msg = queue.next()当messagequeue中有消息，取出来，
然后调用 msg.target.dispatchMessage(msg)，msg.target是Handler对象，这个操作是把msg发给对应的Handler，如果massagequeue中没有消息就阻塞在queue.next()的nativePollOnce方法中(前面有介绍)。这就是为什么为什么主线程不会因为Looper.loop()里的循环卡死。
最后说一下怎样防止Handler内存泄漏
首先分析下原因：是非静态内部类里会持外部引用，如果内部类的生命周期比较长，又碰到生命周期短的对象(如Activity)需要回收就会造成能存泄露。
解决办法1：就是使用静态类加弱引用的方式
public class MainActivity extends AppCompatActivity {
static class MyHandler extends Handler {
//弱引用
private WeakReference m;
public MyHandler(MainActivity mainActivity) {
this.m = new WeakReference(mainActivity);
}
@Override
public void handleMessage(Message msg) {
}
}
}
解决办法2：在 onPause()中使用 Handler 的 removeCallbacksAndMessages(null)方法清除所有消息及回调。
总结一下
1.Handler创建首先要创建先绑定Looper，looper.prepare(), 然后调用loop(),开始循环。(程序启动时会在ActivityThread.main()方法中创建主线程Looper，并开启循环。所以主线程不用手动调用)。
2.Handler的post方法传递的Runnable对象不会开启新的线程。
3.Looper.loop()不会造成应用卡死。
4.Handler要注意内存泄漏问题。
感谢阅读，欢迎点赞收藏。谢谢
参考文章：
https://www.jianshu.com/p/d1da52f0a519
https://www.jianshu.com/p/13c8a66d3b5c