Android 消息处理Handler、 Message 、MessageQueue、Looper、Thread协调配合

android界面控制在ui线程里面，任何子线程都不允许直接操作ui而是借助handler或者activity的post方法等。handler又是如何处理线程间通信的？

1、Handler的声明放在ui主线程中声明然后传递给子线程：

Handler handler=new Handler()
{
public void handleMessage(android.os.Message msg) {

};
};

Handler的源码：

public Handler() {
this(null, false);
}

    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());
            }
        }

        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }

我们主要看黑色部分，函数调用 Looper.mylooper()，返回得到一个looper实例。该实例有个mQueue的成员变量属于MessageQueue的类型。

mCallback为null，mAsynchrous 为false 。

callback可以指定message的处理回调，而不是使用handler的默认handMessage()处理消息的回调。

mAsynchrous 表示该handle是否可以处理异步消息目前还不清楚如何区别别的消息类型。

先看下Looper

public class Looper {
private static final String TAG = "Looper";

// sThreadLocal.get() will return null unless you've called prepare().
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
private static Looper sMainLooper;  // guarded by Looper.class

final MessageQueue mQueue;
final Thread mThread;
volatile boolean mRun;

private Printer mLogging;

创建handler的时候便可以通过Looper.mylooper得到当前线程的looper 通过looper可以得到当前线程的消息队列 mMessageQueue 。Handler调用sendMessage的时候将message压入mMessageQueue。到此为止消息已经成功加入到消息队列当中，那么消息是什么时候，怎么样处理地呢？

回头看看Looper这个类，在创建 Handler的时候 Looper.mylooper()这个Looper的静态方法又是如何得到looper的呢。查找looper的成员函数，可以找到我们熟悉的Looper.prepare()以及Looper.prepareMain()由此可断定，当系统启动的时候即当ui主线程创建的时候android 内部便调用了Looper.prepareMainLooper()方法

/**
* Initialize the current thread as a looper, marking it as an
* application's main looper. The main looper for your application
* is created by the Android environment, so you should never need
* to call this function yourself.  See also: {@link #prepare()}
*/
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.looper()方法，详情参考android源码。可以看到looper方法里面有个循环不断的从mMessageQueue里面拿出消息，再交由message的target的dispatchMessage处理。message的target是一个handler对象，在加入mMessageQueue的时候添加：

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}

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);
}
}

Message 自己有callback是一个runable ，handler也有个Callback 是一个handler类的内部接口，当希望使用自己接口来处理消息回调，可以实现该内部接口的handleMessage(Message msg) 方法。当处理消息的时候优先使用message的callback 其次使用传入handler的callback，再就是handler的handmessage的方法。

这样一波三折子线程的message通过handler传入到主线程的消息队列中并且在主线中执行。这样便可以在子线程中操作ui线程的东西。