Android中的消息机制主要就是指Handler的消息机制，Handler相信大家已经非常熟悉了，它可以将一个任务切换到Handler所在的线程中去执行，开发中，当我们在子线程做了一些操作后需要更新UI，由于Android不允许在子线程中访问UI控件，所以我们一般都会使用handler来实现。
Handler的机制需要MessageQueue、Looper和Message的支持。他们在消息机制中各扮演了不同的角色
Handler：负责消息的发送和接收处理
MessageQueue：消息队列，一个消息存储单位，经常需要进行增减，内部使用的是单链表的结构
Looper：消息循环。会不停地从MessageQueue中取消息，如果有新消息就会立刻处理，否则就一直阻塞在那里
Message：消息载体
下面通过一段简单的代码来分析整个执行过程。
private TextView textView;
private Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
textView.setText("消息处理.....");
}
};
@Override
protected void onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
textView = (TextView) findViewById(R.id.mytv);
new Thread(new Runnable() {
@Override
public void run() {
//模拟耗时操作
SystemClock.sleep(3000);
handler.sendMessage(new Message());
}
}).start();
}
就是在子线程中做了一些耗时操作后，通过Handler发送消息去更新UI
Hanlder是怎么接受到消息的呢？
Looper
Looper几个主要的方法
- Looper.prepare()：为当前线程创建一个Looper
- Looper.loop()：开启消息循环
- Looper.getMainLoop()：可以在任何地方获取到主线程的
- Looper.quit()：直接退出Looper
- quitSafely()：设置一个标记，把消息队列的所有消息处理完后才会退出
//创建一个新的Looper并放到当前线程的ThreadLocal中去
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));
}
再看看Looper的构造方法，发现，Looper中保存有一个MessageQueue
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
loop()该方法是一个死循环，会不断从MessageQueue中去取消息，当获取到消息后，将交由Handler去处理
public static void loop() {
//myLooper方法会从ThreadLocal中获取到当前线程的Looper
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 (;;) {
//不断的去MessageQueue中取消息
Message msg = queue.next();
if (msg == null) {
return;
}
Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " + msg.callback + ": " + msg.what); }
//调用发送该消息的Handler的dispatchMessage方法处理该消息
//这里的msg.target == Handler，是在Handler发送消息的时候进行赋值的
msg.target.dispatchMessage(msg);
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback); }
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();
}
Looper大概就是这么一回事，每条线程绑定一个Looper（子线程需要自己调用Loop.prepare())，保证每条线程都只有一个Looper实例
随后调用Looper.loop开启消息循环，进入堵塞状态，等待消息的到来
MessageQueue
相对来说就很简单来，就两个操作，插入和读取。可以看成一个消息容器
Handler
先来看看他的构造方法
```java
public Handler(Callback callback, boolean async) {
if (FIND_POTENTIAL_LEAKS) {
final Class<? extends Handler> klass = getClass();
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&(klass.getModifiers() & Modifier.STATIC) == 0) {
Log.w(TAG, "The following Handler class should be static or leaks might occur: " + klass.getCanonicalName()); }
}
//获取当前线程中的Looper
mLooper = Looper.myLooper();
if (mLooper == null) {
//如果当前线程没有Looper就会抛出异常。
throw new RuntimeException( "Can't create handler inside thread that has not called Looper.prepare()");
}
//获取Looper中的MessageQueue，可以看出,Looper中为每个线程维护了一个Message
mQueue = mLooper.mQueue;
mCallback = callback;
mAsynchronous = async;
}
接来下看看Handler发送消息的方法，追踪senndmessage到最底层的方法就是enqueueMessage。
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;将发送的Message的target指向当前Handler。
ueue.enqueueMessage(msg, uptimeMillis);往当前线程的MessageQueue插入一条消息
前面在Looper.looper()方法中我们看到msg.target.dispatchMessage(msg); 获取到消息后，调用Handler的dispatchMessage方法进行消息处理。
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);//这里是Message的Callback，也就是开启我们在postDelayed传入的Runnable
} else {
//mCallback：构造器传入的实现
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
//handler自己的handler，一般由派生之类来实现
handleMessage(msg);
}
}
可以看到Handler最终将调用handlerMessage处理消息，当然这里的handlerMessage处理是有优先级的
下面我们总结下流程
流程总结：
1，首先调用Looper.prepare()方法，会创建一个Looper实例，该实例包含一个MessageQueue，并将该实例保存在当前线程中Threadlocal
2，调用Looper.loop()开始消息循环，不断地向MessageQueue中读取消息，并调用msg.target.dispatchMessage(msg);来处理消息
3，构建Handler的时候，会先获取到当前Handler所在线程的Looper并得到其中的 MessageQueue
4，使用Handler发送消息的时候，会将一个Message到保存当前线程Looper中的MessageQueue
5，当Looper.loop()获取到消息的时候，调用msg.target.dispatchMessage(msg)来处理消息,其实Message.target = handler。也就是调用Handler的dispatchMessage来处理
6，Handler的dispatchMessage最终回去调用handlerMessage方法。到这里就知道，其实Handler的handler在哪条线程执行，取决于构建Handler时所使用的是哪条线程保存的Looper，因为handlerMessage其实是Looper去调用的。
下面通过一张图来表述下具体流程
前面说到，Handler必须有Looper才能执行，或者会就抛出异常，当前我们在日常使用中，直接在Activity中定义Handler就可以用啦，并没有说调用Looper.prepare来进行初始化操作。
其实UI线程默认已经做了这些操作了。对于我们来说是隐形的
大家都知道Android的程序入口是ActivityThread类，他有个main方法，我们看看他做了什么
public static void main(String[] args) {
//省略。。。。
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
AsyncTask.init();
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
可以看到main方法主要就是消息循环，当main方法结束了，你的程序也就退出了
可能有人会问？UI线程已经做了Looper.loop()了？loop不是一个死循环堵塞状态吗？为什么我们程序还能跑起来。
既然main方法只是做了消息循环，那么我们Activity的生命周期的方法是怎么执行的呢？
在ActivityThread中有个Handler，Activity的生命周期方法在里面均有case，也就说是我们的代码其实就是在这个循环里面去执行的，自然不会阻塞了
当前我还有个疑惑。程序是在哪给ActivityThread的Handler发消息的呢？这个我暂时还不清楚。。还得继续学习啊。
UI线程已经帮我们做了这些工作了，但是如果我们自己new Thread的话，需要在子线程中使用Handler的话，还是要自己来实现的。
对此，Android也为我们提供了一个HandlerThread类，方便我们快速的实现需求。
HandlerThread继承了Thread
public class HandlerThread extends Thread
代码相当简单，
看看run方法
@Override
public void run() {
mTid = Process.myTid();
Looper.prepare();
synchronized (this) {
mLooper = Looper.myLooper();
notifyAll();
}
Process.setThreadPriority(mPriority);
onLooperPrepared();
Looper.loop();
mTid = -1;
}
如果对前面的Handler机制理解了话，这里是不是一目了然了呢？
