首先来点基础描述:
主线程的handler的looper，也就是Loop.getMainLooper()返回的loop,默认在ActivityThread类的main方法初始化了 ,在main方法里面调用了Loop.perpareMainLoper();初始化了一个loop,所以一般主线程的looper实际上就是那里初始化的looper具体ActivityThread类的main```代码如下:
public static void main(String[] args) {
CloseGuard.setEnabled(false);
Environment.initForCurrentUser();
Process.setArgV0("<pre-initialized>");
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.
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
}
创建了一个默认的loop又维护了一个messageQuare主线程的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;
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
return;
}
try {
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
}
msg.recycleUnchecked();
}
}
那么handler类里面的dispatchMessage触发是因为添加到消息队列中的消息Message类的``target被设置了handler,然后在Looper类的loop方法里面处理这个消息的时候触发，也就是下面的这句代码 msg.target.dispatchMessage(msg);```
try {
msg.target.dispatchMessage(msg);
} finally {
if (traceTag != 0) {
Trace.traceEnd(traceTag);
}
}
msg.target.的成员变量为handler,也就是代码是从这里调用的。
Looper相关方法
构建loop静态对象 保证一个线程只有一个
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
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));
}
至于Looper.loop()方法上面已经贴过了，也就是开启轮训，当没有的时候cpu进入等待。这个和某个酷Q机器人易语言源码当中的消息处理惊人的相似。他那个差不多就是消息队列的死循环，没有的时候就进行睡眠，然后有消息的时候线程唤醒。
里面用到了ThreadLocal通过线程名作为键，保证了一个线程只有一个ThreadLocal一个Looper
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
ThreadLocal的关键方法
public void set(T value) {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null)
map.set(this, value);
else
createMap(t, value);
}
源码太深，这里只讲如何被设置上去的，
根据handler的源码分析，post postDelay实际上都最终调用了sendMessageAtTime然后调用了
return enqueueMessage(queue, msg, uptimeMillis);
那么继续，先看看handler的一些方法，
public final Message obtainMessage()
{
return Message.obtain(this);
}
public final Message obtainMessage(int what)
{
return Message.obtain(this, what);
}
public final Message obtainMessage(int what, Object obj)
{
return Message.obtain(this, what, obj);
}
这里都把handler传递进去了
Message的obtain方法设置了 m.target
public static Message obtain(Handler h, int what, Object obj) {
Message m = obtain();
m.target = h;
m.what = what;
m.obj = obj;
return m;
}
既然是这样的，那么自己创建一个纯message类会触发吗？
Message message=new Message();
message.what=1;
message.obj="测试纯message";
handler.sendMessage(message);
结果令人震惊，还是触发了，这message.taget他是如何被设置的呢？
然后又看了看，原来那报错的红色代码没有被我注意到,也就是说追踪走的sendMessageAtTime方法走的enqueueMessage方法中强制给message的targer设置了handler为自己。
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; 所以 明白为什么可以回调了，ok讲解完毕，知其然也知其所以然了。
其它相关
1、handler类的queue成员变量是从Looper中获取到的,handler发消息实际上是拿到Looper里面的静态消息队列字段
mLooper.mQueue
2、而mQueue = new MessageQueue(quitAllowed);也就是消息队列对象的初始化是通过prepare的调用导致sThreadLocal.set(new Looper(quitAllowed));这句代码被执行，然后导致Looper构造方法执行，然后触发这个队列的初始化。···mQueue = new MessageQueue(quitAllowed);···
sThreadLocal也就是ThreadLocal默认在成员变量就初始化了sThreadLocal而且是静态的 这个字段也是放到Looper类里面存起来的
3、真正负责处理消息的是在looper()开启一个死循环for,不断的0调用MessageQueue的next() 知道返回null才终止，,在这个方法几乎是没法出来了，永远卡在这个方法,除非满足特定条件，`比如messagequare的quit方法被调用。
4、looper的looper死死循环外，消息队列MessageQueue next也嵌套了一个死循环，所以即使消息没有也不会进行立马返回，而是等待，只有当有消息的时候才返回给looper()处理这里面主要做一些时间的处理，比如那些延时时间发送的。
有些东西还是没法理解，深度对我来说还是遥不可及
