android 消息机制

android的消息机制，这肯定是被大家源码解析，分析坏了的一部分。首先这个消息机制用的比较频繁，主要用在子线程更新UI，再一个就是这个源码比较少，也是很好理解的，我感觉每个人都会来一篇消息机制的文章。

Android消息机制概述

说到Android的消息机制，大家肯定会想到Handler。是的，Android的消息机制主要是指Handler的运行机制以及Handler所附带的MessageQueue和Looper的工作过程。当我们工作的时候我们只要接触到Handler就可以了。

为什么要有Android消息机制？

我们知道Handler的主要作用是将一个任务切换到某个指定的线程去执行，比如Android规定访问UI只能在主线程中进行，如果在子线程中访问那么程序会抛异常，如下所示：

void checkThread(){
if(mThread != Thread.currentThread()){
throw new CalledFromWrongThreadException(
"Only the original thread that created a view hierarchy can touch its views.");
}
}

为什么系统不允许在子线程中访问UI呢？这是因为Android的UI控件不是线程安全的，如果在多线程中访问UI控件则会导致不可预期的状态。那为什么不对UI控件访问加锁呢？缺点有两个：首先加锁会让UI控件的访问的逻辑变的复杂；其次，锁机制会降低UI的访问效率。那我们不用线程来操作不就行了吗？但这是不可能的，因为Android的主线程不能执行耗时操作，否则会出现ANR。所以，从各方面来说，Android消息机制是为了解决在子线程中无法访问UI的矛盾。
在这里就不进行MessageQueue和Looper的分析了，大家如果想看可以百度，或者自己去看下源码就都可以看懂的。我们接下来主要分析Handler处理消息的几种方式，以及他们在执行时的顺序。
我们都知道主线程是可以直接new Handler()的，而在子线程中却是不可以的，我们去看下这是为什么？
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}如果在子线程中会报这么一个错误，这是因为在子线程中没有Looper对象。如果子线程也想创建Handler，可以去参考HandlerThread这个类的实现。为什么主线程是可以的，那就要去找一个ActivityThread的类了，这是在应用启动的时候开启的一个线程也是传说中的UI线程或主线程，源码：
public static void main(String[] args) {
  ...
    //这个地方就是创建一个Looper，并且放在ThreadLocal里。下面会有源码
Looper.prepareMainLooper();

ActivityThread thread = new ActivityThread();
thread.attach(false);

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);
    // Loop.loop（）是一个死循环，但是在没有消息的时候会堵塞
Looper.loop();

throw new RuntimeException("Main thread loop unexpectedly exited");
}

public static void prepareMainLooper() {
// 这里就是创建Looper的方法
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
        // 这个地方就是把在prepare(false)中存入的Looper取出来
sMainLooper = myLooper();
}
}

private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
    //创建一个Looper放到ThreadLocal里面
sThreadLocal.set(new Looper(quitAllowed));
}

public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}这个地方用到了ThreadLocal，大家可以自己去自行百度。好了这个地方已经解释了UI线程里面可以new Handler的原因。下面就是我们要解释Handler出来消息的几种方式。
在这我就默认大家都是知道Message在处理的时候是调用msg.target.dispatchMessage()方法来处理，这个msg.target就是我们Handler。下面我们来看下这个dispatchMessage方法
/**
* Handle system messages here.
*/
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
        // 处理消息的第一种方式
handleCallback(msg);
} else {
if (mCallback != null) {
            // 处理消息的第二种方式
if (mCallback.handleMessage(msg)) {
return;
}
}
        // 处理消息的第三种方式
        handleMessage(msg);
    }
}在这里可以看出处理消息有三种方式，并且彼此不会重叠，都是执行一次。
第一种方式：

private static void handleCallback(Message message) {
message.callback.run();
}这个地方message.callback是什么地方给的呢？

handler.post(new Runnable() {
@Override
public void run() {

}
});

public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}private static Message getPostMessage(Runnable r) {
     //这个地方就是把Runnable赋值给Message的callback了，也就有我们上面代码的调用了
Message m = Message.obtain();
m.callback = r;
return m;
}第二种方式：Handler为了防止在创建是都要写一个子类，所以提供了一个接口，也就是Handler.Callback

public interface Callback {
public boolean handleMessage(Message msg);
}

Handler的创建方式：

Handler handler = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
return false;
}
});

这种方式处理完Message不要忘记返回true。
第三种方式：调用handleMessage方法
Handler的创建方式：
Handler handler2 = new Handler(){
@Override
public void handleMessage(Message msg) {
}
};就会调用我们写的handleMessage方法，进行处理Message。