前言
Android的消息机制主要是指Handler的运行机制以及Handler所附带的MessageQueue和Looper的工作过程，这三者其实是一个整体。这三个对象都与其对应的线程对应，然后A线程通过调用B线程的handler发送消息，这个消息就会被加入线程B的MessageQueue中，线程B的Looper发现有消息到来，就会去处理他，通过dispatchMessage()，最后回调handler的handlerMessage方法。Handler的主要作用是将一个任务切换到某个指定的线程中去执行,安卓之所以提供这个功能是因为安卓规定访问UI只能在主线程中进行。
Handler怎么用?
1.继承Handler类，重写handlerMessage方法。
这里我们一般采用弱引用或者静态内部类来实现，因为采用非静态内部类会导致内存泄露。（持有Activity的引用）。
public class Main2Activity extends AppCompatActivity {
private final MyHandler mHandler = new MyHandler(this);
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main2);
}
private static class MyHandler extends Handler {
private final WeakReference<Main2Activity> main2ActivityWeakReference;
private MyHandler(Main2Activity main2ActivityWeakReference) {
this.main2ActivityWeakReference = new WeakReference<Main2Activity> (main2ActivityWeakReference);
}
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
}
}
}在创建的时候，我们也可以传递一个Callback对象。这个对象会返回一个布尔值，根据这个布尔值我们可以控制是否执行接下来的操作，实现对消息的拦截。当返回true的时候，我们就不会执行下面的handlerMessage。这和我们的dispatchMessage有关，后面将会进行分析。
public static Handler mHandler = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
return false;
}
}){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
}
};2。使用post()/sendMessage（）方法发送消息。
上面的是我们Handler接受到方法后需要处理的逻辑，接下来我们了解一下怎么发送消息。（Hanler给我们提供了定时器的功能）
post（Runnable r）/postDelayed(Runnable r，long times)
发送一个runnable到handler所在的线程中去。
mHandler.post(new Runnable() {
@Override
public void run() {
//需要到handler线程的操作
}
},1000);
}实现定时器功能。
public class MainActivity extends Activity {
private EditText editText1;
TextView textView1;
static Handler handler = new Handler();
static Runnable runnable = new Runnable() {
@Override
public void run() {
handler.postDelayed(this, 2000);
Toast.makeText(MainActivity.this, "YQY_Editor", Toast.LENGTH_SHORT).show();
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
textView1 = (TextView) findViewById(R.id.textView1);
textView1.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View arg0) {
handler.postDelayed(runnable, 2000);
}
});
}
} 当我们要移除的时候，调用 handler.removeCallbacks(runnable); 即可。但是如果我们没有把runnable 设置为静态的话，当activity从后台进入前台再次运行时，会失效。因为这个时候从message queue移除的runnable与原先加入message queue中的runnable并非是同一个对象。
sendMessage(message)
new Thread(new Runnable() {
@Override
public void run() {
//发送一个空消息
mHandler.sendEmptyMessage(1);
//携带内容发送
Message message=new Message();
message.what=1;
message.obj="haha";
mHandler.sendMessage(message);
//从消息队列中获取，避免了new Message的内存开销，
// 其源码执行了target.sendMessage()方法，而target就是handler
Message m = mHandler.obtainMessage();
m.sendToTarget();
}
});3.在子线程中处理消息。
上面都是在主线程中处理接受消息。接下来我们说说怎么在子线程中去接受。前言我们说过，Handler是和MessageQueue以及Looper一起协同工作的，所以我们创建Handler就必须要有一个Looper，否则就会抛出异常。那么，这里就有一个问题了。为什么我们在主线程创建的时候不需要准备和开启一个Looper呢？那是因为的主线程的main方法中，已经替我们初始化好了Looper。接下来示范一下如何为线程去准备一个Looper，其实也很简单的~
new Thread(new Runnable() {
@Override
public void run() {
Looper.prepare();
handler1=new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
break;
}
}
};
Looper.loop();
}
});
三个小伙胖
关系
Hanlder:在Android中主要是封装了消息的发送。
Looper：类似一个“消息泵”，产生动力，接收Handler发送过来的消息，并且在Looper中存在一个loop方法和一个MessageQueue对象，通过loop方法一直轮询，从MessageQueue中取出消息，并回传给Hanlder自己
MessageQueue:就是一个存储消息的容器。
一起工作
Handler创建的时会采用当前线程Looper来构建内部的消息循环系统，如果当前线程没有Looper，那么就会报错。Looper对象执行loop()方法（是一个死循环）后，会不断对其内部的MessageQueue进行轮询。这个时候其内部的Looper以及MessageQueue就可以和Handler一起协同工作了。通过Handler的post方法将一个Runnable投递到Handler内部的Looper去处理，也可以通过Handler的send方法发送一个消息，这个消息同样会在Looper中去处理。其实post方法最终也是通过send方法完成的。Send方法被调用时，因为默认发送到的目标（target）就是Handler本身，因此每次发送的消息都会发送到Handler内部所关联的Looper，然后Looper会将消息加入到MessageQueue中去。然后Looper发现有新消息到来时，就会处理这个消息，最终消息中的Runnable或者Handler的handlerMessage方法就会被调用。如果没有，则处于阻塞状态。注意，Looper是运行在创建Handler所在的线程中，这样依赖Handler中的业务逻辑就被切换到创建Handler所在的线程去执行了。
深入源码
MessageQueue的工作原理
消息队列在安卓中主要指的是MessageQueue。虽然叫他消息队列，但是其实他的内部实现是一个单链表，因为单链表在插入和删除上有优势。我们主要看两个方法，一个是插入消息enqueueMessage，一个是读取消息next（读取就会伴随着移除消息）
首先看一下enqueueMessage的源码：（简化了）
boolean enqueueMessage(Message msg, long when) {
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;
}
}我们可以发现这里其实就是一个链表的插入操作。
再来看看next的源码：（简化了）
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
// Try to retrieve the next message. Return if found.
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
// Stalled by a barrier. Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
// Next message is not ready. Set a timeout to wake up when it is ready.
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;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}
// Process the quit message now that all pending messages have been handled.
if (mQuitting) {
dispose();
return null;
}next方法是一个无限循环的方法，如果没有新消息来就会一直阻塞在这里，当获得新消息，会将这条消息从单链表中移除并且返回。当我们退出的时候，会返回Null。（消息队列被标志为退出状态）
Looper的工作原理
Looper在Android消息机制中扮演着无限循环的角色。它会一直等待消息队列中的消息，将有消息来就会处理，没有将会一直阻塞在那里。
它的构造方法其实就是创建了一个新的队列并且获得当前的线程。
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
首先我们看一下它的prepare方法：
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));
}
可以看到我们prepare方法只能执行一次，否则会报错。这里出现了一个sThreadLocal，我们会在后面对其进行分析。现在就可以先把它当成一个线程私有的储存器。也就是说，我们prepare的时候其实就是初始化一个Looper并将它放入我们私有的储存器中。
在源码中，我们还可以看到安卓还替我们提供了一个prepareMainLooper()方法，它主要是给主线程创建Looper使用的，其本质其实也是通过prepare实现的，通过它我们可以再任意地方获得主线程的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();
}
}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();
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方法也是一个死循环，只有当MessageQueue的next方法返回Null才会跳出循环。上面分析过，当没有消息的时候，next方法会一直阻塞，而当获得消息后，就会调用target（其实就是发送这条消息的handler）的dispatchMessage(msg)进行处理。这样，我们就成功的将代码逻辑切换到指定的线程中去执行啦。
源码中还有两个方法分别是 public void quit()和public void quitSafely()当调用这两个方法后，Loop就会通知 消息队列将其标记为退出状态。两个方法的不同在于，quit会直接退出，而后者只是设置了一个退出标记，然后把消息队列中的消息处理完后才会安全的退出。Looper退出后通过Handler发送的消息就会失败，send方法返回false。所以，我们如果再子线程中手动创建了Looper，完成所有的事情后就应该调用quit来终止消息循环，否则这个线程会一直处于等待的状态。因此建议不需要的时候终止Looper。
ThreadLocal的原理。
ThreadLocal其实就是一个线程内部的数据存储类。通过它可以在指定的线程中存储数据，数据存储以后，只有在指定的线程才可以获取到存储的数据。当某些数据是以线程为作用域而且不同线程具有不同的副本的时候，就可以考虑采用。
其实原理就是从各自的线程中取出一个数组，然后再从数组中根据当前ThreadLocal的索引去查找出对应的value值。在数组中最终的值是table[index+1] = valuse。
它的两个作用：
- 系统可以不用提供一个全局的哈希表来供Handler查找指定的Looper。
- 复杂逻辑下的对象传递，比如说监听器的传递。
Handler的工作原理。
首先我们看看消息的发送过程：
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
可以发现，它只是向消息队列插入了一条消息。
再看看我的Post：
public final boolean postDelayed(Runnable r, long delayMillis)
{
return sendMessageDelayed(getPostMessage(r), delayMillis);
}
它也的确只是把我们的runnable封装成了一个Message，最后调用send方法。
除此之外，Handler还有一个特殊的构造方法。他可以为Handler指定一个Looper.
public Handler(Looper looper) {
this(looper, null, false);
}最后，我们来看看它是怎么处理消息的，也就是我们的dispatchMessage方法。
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}这也就验证了我们上面使用方法中提到的消息的拦截处理。其中我们的msg.callback其实就我们的runnable。
总结
Handler的主要作用是：
1. 更新UI
2. 发送消息、处理消息，其中应用的例子有：
所有的Activity的生命周期的回调方法，包括onCreate、onResume、onDestroy等方法，以及Button点击事件的分发等，内部其实都是通过Handler机制发送消息来回调的，然后根据不同的Message进行相应的分支处理。其中主要是通过Activity Manager Service（AMS）来给Handler发送消息的。例如AMS可能会发送一个请求启动Activity的消息给Handler，然后Handler根据接收到的相应的消息分别执行对应的生命周期回调方法。
参考：
- Android开发艺术探索
- 苏zr小哥哥的笔记。
- 图来源于罗杰学长的面试总结。
- Android中的Handler解析
感谢~
晚安~
985
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
