1.关于Message,MessageQueue,Handler和Looper的关系：Looper不断的从MessageQueue中取出消息，交给Handler去处理，looper和线程绑定
来看一下这几个类的源码
参考Message 源码，其主要成员变量如下：
public final class Message implements Parcelable { public int what;
public int arg1;
public int arg2;
public Object obj;
public Messenger replyTo;
public int sendingUid = -1;
private static final Object sPoolSync = new Object();
private static Message sPool;
private static int sPoolSize = 0;
private static final int MAX_POOL_SIZE = 50;
private static boolean gCheckRecycle = true;
.......
}
这些成员变量中what用来保存消息标识，arg1和arg2是用来存放整型数据的，obj存储人员类型变量，replyTo是消息管理器，会关联到一个handler。通常使用Message.obtain获取message，避免创建多余对象节约内存，从源码看sPool为null时会自动new Message出来。
MessageQueue
public final class MessageQueue {
// True if the message queue can be quit.
private final boolean mQuitAllowed;
MessageQueue(boolean quitAllowed) {
mQuitAllowed = quitAllowed;
//构造方法，调用了native方法
mPtr = nativeInit();
}
//队列操作
boolean enqueueMessage(Message msg, long when) //入队
Message next() //出队
void removeMessages(Handler h, Runnable r, Object object) //根据Runable删除队列元素
void removeMessages(Handler h, int what, Object object) //根据Message.what删除队列元素
private void dispose() //销毁队列
.....
}
Handler的构造函数如下：
public Handler()
public Handler(Callbackcallback)
public Handler(Looperlooper)
public Handler(Looperlooper, Callbackcallback)
其主要成员变量如下
public class Handler {
final MessageQueue mQueue;
final Looper mLooper;
final Callback mCallback;
final boolean mAsynchronous;
IMessenger mMessenger;
......
}
第1个和第2个构造函数都没有传递Looper，这两个构造函数都将通过调用Looper.myLooper()获取当前线程绑定的Looper对象，然后将该Looper对象保存到名为mLooper的成员字段中。
第3个和第4个构造函数传递了Looper对象，这两个构造函数会将该Looper保存到名为mLooper的成员字段中。
第2个和第4个构造函数还传递了Callback对象，Callback是Handler中的内部接口，需要实现其内部的handleMessage方法，其中Callback接口如下，该接口处理Message消息。因此处理Message消息有重写Handler的handleMessage方法或者在初始化Handler的时候传入一个Handler.CallBack接口，源码中优先判断Handler.CallBack是否为空
public interface Callback {
/**
* @param msg A {@link android.os.Message Message} object
* @return True if no further handling is desired
*/
public boolean handleMessage(Message msg);
}
把Message消息放入队列的方法如下：
public final boolean post(Runnable r)
public final boolean postDelayed(Runnable r, long delayMillis)
public final boolean sendMessage(Message msg)
public final boolean sendEmptyMessage(int what)
Looper
public final class Looper {
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
private static Looper sMainLooper; // guarded by Looper.class
final MessageQueue mQueue;
final Thread mThread;
......
}
注释中给出了looper的典型用法：
* <pre>
* class LooperThread extends Thread {
* public Handler mHandler;
*
* public void run() {
* Looper.prepare();
*
* mHandler = new Handler() {
* public void handleMessage(Message msg) {
* // process incoming messages here
* }
* };
*
* Looper.loop();
* }
* }</pre>
*/
看一下Looper.prepare()和Looper.loop()具体做了什么
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
//通过sThreadLocal.get()判断保证一个Thread只能有一个Looper实例
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
//new一个looper来初始化looper
sThreadLocal.set(new Looper(quitAllowed));
}
private Looper(boolean quitAllowed) {
//在looper的构造函数中创建MessageQueue
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
再来看一下Handler是如何跟looper关联的：Handler中就持有一个Looper，Looper类提供myLooper()方法提供looper
//Looper中的myLooper()
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
//Handler构造函数
public Handler(Callback callback, boolean async) {
......
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类同时提供了获取UI线程looper的方法 getMainLooper()
/**
* Returns the application's main looper, which lives in the main thread of the application.
*/
public static Looper getMainLooper() {
synchronized (Looper.class) {
return sMainLooper;
}
}
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
Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
msg.target.dispatchMessage(msg);
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();
}
}
进入for循环后，开始从MessageQueue中取出一个消息（可能会阻塞），如果当前消息队列中没有Message，线程退出；否则分发消息。msg.target.dispatchMessage(msg)中的target就是一个Handler。最后消息处理完毕，进行回收。
为何主线程不需要调用Looper.looper和Looper.prepare
普通线程只要prepare就可以了，而主线程使用的是prepareMainLooper；普通线程生成一个与Looper绑定的Handler对象就行，而主线程是从当前线程中获取Handler（thread.getHandler()）
我们看一下ActivityThread（UI线程）的源码，ActivityThread在应用程序启动的时候由系统创建出来
public static void main(String[] args) {
......
Looper.prepareMainLooper();
ActivityThread thread = new ActivityThread();
thread.attach(false);
if (sMainThreadHandler == null) {
//主线程获取Handler
sMainThreadHandler = thread.getHandler();
}
......
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
//初始化主线程的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
public static Looper getMainLooper() {
synchronized (Looper.class) {
return sMainLooper;
}
}
对于主线程，thread.getHandler()返回的就是mH
如上，一个thread通过sThreadLocal.get来保证只有一个looper，主线程在ActivityThread创建了一个Handler（mH），子线程通过Looper.myLooper获取looper。每个looper只对应一个MessageQueue,每个Message最多指定一个Handler来处理.Thread和Handle是一对多的关系.