常用场景：
子线程发送Message 
主线程处理Message

子线程发送消息

    public final boolean sendEmptyMessageDelayed(int what, long delayMillis) {Message msg = Message.obtain();msg.what = what;return sendMessageDelayed(msg, delayMillis);}public final boolean sendEmptyMessage(int what){return sendEmptyMessageDelayed(what, 0);}

不管那种方式发送小时最终都走到 sendMessageAtTime

public boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {MessageQueue queue = mQueue;if (queue == null) {RuntimeException e = new RuntimeException(this + " sendMessageAtTime() called with no mQueue");Log.w("Looper", e.getMessage(), e);return false;}return enqueueMessage(queue, msg, uptimeMillis);}private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,long uptimeMillis) {msg.target = this;msg.workSourceUid = ThreadLocalWorkSource.getUid();if (mAsynchronous) {msg.setAsynchronous(true);}return queue.enqueueMessage(msg, uptimeMillis);}

通过enqueueMessage将消息按照时间先手插入到MessageQueue中

主线程处理消息

应用启动：

frameworks\base\core\java\android\app\ActivityThread.java

main方法中关注Looper.prepareMainLooper()和Looper.loop().

Looper.prepareMainLooper()

 public static void prepareMainLooper() {prepare(false);synchronized (Looper.class) {if (sMainLooper != null) {//Looper的唯一性throw new IllegalStateException("The main Looper has already been prepared.");}sMainLooper = myLooper();}}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));}private Looper(boolean quitAllowed) {mQueue = new MessageQueue(quitAllowed);mThread = Thread.currentThread();//绑定当前线程}MessageQueue(boolean quitAllowed) {mQuitAllowed = quitAllowed;mPtr = nativeInit();}void quit(boolean safe) {if (!mQuitAllowed) {throw new IllegalStateException("Main thread not allowed to quit.");}
......
}

1. prepare创建 Looper 并设置给了sThreadLocal 后面loop中要获取

2.prepare创建不可退出的MessageQueue(因为在主线程)

Looper.loop()

 public static void loop() {final Looper me = myLooper();......me.mInLoop = true;final MessageQueue queue = me.mQueue;for (;;) { //死循环Message msg = queue.next(); // might block......try {msg.target.dispatchMessage(msg);if (observer != null) {observer.messageDispatched(token, msg);}dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;} catch (Exception exception) {if (observer != null) {observer.dispatchingThrewException(token, msg, exception);}throw exception;} finally {ThreadLocalWorkSource.restore(origWorkSource);if (traceTag != 0) {Trace.traceEnd(traceTag);}}......msg.recycleUnchecked();}}public static @Nullable Looper myLooper() {return sThreadLocal.get();}

1.Looper持有了当前线程的MessageQueue

2.通过queue.next() 获取当前时间下一次要执行的Message

3.处理消息 msg.target.dispatchMessage(msg) 分发到内部类中处理（msg.target就是当前消息绑定的Handler）

4. 消息回收（消息复用） msg.recycleUnchecked()

流程：应用启动-->ActivityThread main 启动 --> 准备Looper  --> Looper死循环  一直取队列中的消息  -->处理消息 --> 消息回收处理

PS: 应用异常（Runtime）时压栈最底下ActivityThread.main()   倒数第二行Looper.loop()    这也印证了启动的顺序

Handler创建

常见创建：

Handler handler=new Handler(){@Overridepublic void handleMessage(Message msg) {super.handleMessage(msg);}
};public Handler() {this(null, false);}public Handler(@Nullable Callback callback, boolean async) {mLooper = Looper.myLooper();//获取Looperif (mLooper == null) {throw new RuntimeException("Can't create handler inside thread " + Thread.currentThread()+ " that has not called Looper.prepare()");}mQueue = mLooper.mQueue;//获取消息队列mCallback = callback;//注册回调mAsynchronous = async;}public interface Callback {boolean handleMessage(@NonNull Message msg);}

消息创建

new Message

   /** Constructor (but the preferred way to get a Message is to call {@link #obtain() Message.obtain()}).*/public Message() {}

Google 没有详细说明new  Message 当通过我们实际直接new 就完事了无需多言，不过Google推荐使用Message.obtain() 去创建

方法一：
Message msg = Message.obtain()
--------------------------------源码-------------------------------public static Message obtain() {synchronized (sPoolSync) {if (sPool != null) {Message m = sPool;sPool = m.next;m.next = null;m.flags = 0; // clear in-use flagsPoolSize--;return m;}}return new Message();}
方法二：
Handler handler = new Handler();
Message msg = handler.obtainMessage();//绑定了handler
--------------------------------源码-------------------------------
public final Message obtainMessage(){return Message.obtain(this);// this==handler}public static Message obtain(Handler h) {Message m = obtain();m.target = h;return m;}

不管那种方式创建最终都是走无参的obtain方法
1.sPool等于空时通过new 创建Message
2.sPool 是在Looper dispatch 出去后通过recycleUnchecked清空后到Message

3.sPool最前面的空Messsage返回回去，sPool指针后移队列到下一个保证下一个obtain可以正确获获取到sPool中的空Message

Message和handler的绑定
1.可以在创建Message是绑定，参考Message创建的方法二
2.消息发送是绑定
回到发送Message

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

总结：

 

Thread thread = new Thread(new Runnable() {Looper looper;
@Override
public void run() {Looper.prepare();looper =Looper.myLooper();Looper.loop();
}
public Looper getLooper() {return looper;
}
});thread.start();Handler handler = new Handler(thread.getLooper());

public class HandlerThread extends Thread {Looper mLooper;@Overridepublic void run() {mTid = Process.myTid();Looper.prepare();synchronized (this) {mLooper = Looper.myLooper();notifyAll();}Process.setThreadPriority(mPriority);onLooperPrepared();Looper.loop();mTid = -1;}public Looper getLooper() {if (!isAlive()) {return null;}// If the thread has been started, wait until the looper has been created.synchronized (this) {while (isAlive() && mLooper == null) {try {wait();} catch (InterruptedException e) {}}}return mLooper;}