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

class LooperThread extends Thread {
  public Handler mHandler;

  public void run() {
      Looper.prepare(); // 1. 准备好 looper 对象
      mHandler = new Handler() { //2. 创建一个handler对象,并指明消息处理函数
          public void handleMessage(Message msg) {
              // process incoming messages here
          }
      };
      Looper.loop(); //3.开始该线程内部消息循环
  }
}

public class MainActivity extends Activity {
    private Handler mHandler = new Handler(){//创建主线程绑定的handler对象
        @Override
        public void handleMessage(android.os.Message msg) {
            switch(msg.what) {
            case 1:
                mText.setText("download Ok!");
                break;
            }
        };
    };

protected void onCreate(Bundle savedInstanceState) {
    ...
    mButton.setOnClickListener(new OnClickListener {
        @overide
        public void onClick() {
          new Thread(new Runable() {
            @overide
            public void run() {
                 //模拟等待 2s
                 Thread.sleep(2);
                 // 2s后发送消息给主线程通知下载完毕
                 Message msg = Message.obtain();
                 msg.what = 1;
                 mHandler.sendMessage(msg);
                }
             })
            }).start();
        ...
}

public static void prepare() {
    prepare(true);
}

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对象并设置线程私有变量中
}

private Looper(boolean quitAllowed) {
    mQueue = new MessageQueue(quitAllowed);// Looper 对象的构造本质是创建一个消息队列
    mThread = Thread.currentThread();
}

package android.os;

MessageQueue(boolean quitAllowed) {
    mQuitAllowed = quitAllowed;
    mPtr = nativeInit();//调用 android_os_MessageQueue.cpp 中native方法初始化
}

private long mPtr; // used by native code
private native static long nativeInit();// native 方法

static jlong android_os_MessageQueue_nativeInit(JNIEnv* env, jclass clazz) {
    NativeMessageQueue* nativeMessageQueue = new NativeMessageQueue();//创建一个native 层消息队列
    if (!nativeMessageQueue) {
        jniThrowRuntimeException(env, "Unable to allocate native queue");
        return 0;
    }

    nativeMessageQueue->incStrong(env);
    return reinterpret_cast<jlong>(nativeMessageQueue);//返回native层消息队列的指针
}

public static void loop() {
    final Looper me = myLooper();//1.获取该线程的 Looper对象
    ...
    final MessageQueue queue = me.mQueue;//获取该线程的 MsgQueue
    ...//省略

    for (;;) {//开始死循环获取msg
        Message msg = queue.next(); // might block，取出下一条消息执行，没消息时阻塞等待
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return; //退出消息循
        }
        ...
        msg.target.dispatchMessage(msg);//msg.target 就是 handler，通过 handler 派发出去
        ...
        msg.recycleUnchecked();// msg 是一个消息池，用完后回收
    }
}

Message next() {
    ...
    final long ptr = mPtr;
    ...
    
    //刚开始迭代时初始化参数
    int pendingIdleHandlerCount = -1; // -1 only during first iteration
    int nextPollTimeoutMillis = 0; //首次默认不等待
    for (;;) {
        ...

        nativePollOnce(ptr, nextPollTimeoutMillis);//等消息，最大等待时间依据nextPollTimeoutMillis 的值

        synchronized (this) {
            // Try to retrieve the next message.  Return if found.
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;
            if (msg != null && msg.target == null) {
                // Stalled by a barrier.  Find the next asynchronous message in the queue.
                do {
                    prevMsg = msg;
                    msg = msg.next;
                } while (msg != null && !msg.isAsynchronous());
            }
            if (msg != null) {// 当消息队列不为空时
                if (now < msg.when) {//若是延迟消息，则计算还要等待的最大timeout时间
                    // Next message is not ready.  Set a timeout to wake up when it is ready.
                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                } else {//消息队列不为空，且消息执行时间符合，开始获取一条消息
                    // Got a message.
                    mBlocked = false; //将阻塞变量设为false
                    //基于链表操作，获取消息队列的首条消息
                    if (prevMsg != null) {
                        prevMsg.next = msg.next;
                    } else {
                        mMessages = msg.next;
                    }
                    msg.next = null;
                    if (DEBUG) Log.v(TAG, "Returning message: " + msg);
                    msg.markInUse();
                    return msg; //立即 return, next()就直接返回了
                }
            } else {//如果消息队列为空，说明当前无任何消息，设置无限等待标志（-1）
                // No more messages.
                nextPollTimeoutMillis = -1;
            }

            // Process the quit message now that all pending messages have been handled.
            if (mQuitting) {
                dispose();
                return null;
            }

            // 逻辑能走到这里，说明消息队列为空，或者首个消息队列还没到时间执行时间，那么就趁着这个完全空闲的执行，执行空闲的操作
            
            // If first time idle, then get the number of idlers to run.
            // Idle handles only run if the queue is empty or if the first message
            // in the queue (possibly a barrier) is due to be handled in the future.
            //若消息队列为空或者首条消息未到执行时间，获取 idlerHandler的大小
            if (pendingIdleHandlerCount < 0
                    && (mMessages == null || now < mMessages.when)) {
                pendingIdleHandlerCount = mIdleHandlers.size();
            }
            //若此时未有pengdingIdleHanlder的任务，说明没有空闲执行的任务，那就直接等下一条消息到来
            if (pendingIdleHandlerCount <= 0) {
                // No idle handlers to run.  Loop and wait some more.
                mBlocked = true; //阻塞设置为 true
                continue; // 直接下一轮，实际是直接应用 nextPollTimeoutMillis 来做等待
            }

            //下面是有pending的空闲任务，则逐一回调执行，
            if (mPendingIdleHandlers == null) {
                mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
            }
            mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
        }

        // Run the idle handlers.
        // We only ever reach this code block during the first iteration.
        for (int i = 0; i < pendingIdleHandlerCount; i++) {
            final IdleHandler idler = mPendingIdleHandlers[i];
            mPendingIdleHandlers[i] = null; // release the reference to the handler

            boolean keep = false;
            try {
                keep = idler.queueIdle();
            } catch (Throwable t) {
                Log.wtf(TAG, "IdleHandler threw exception", t);
            }

            if (!keep) {
                synchronized (this) {
                    mIdleHandlers.remove(idler);
                }
            }
        }
        
        // pending 任务做完了，立即设置 空闲任务为0，且等待时间为0，因为可能现在消息队列可能有消息了，直接查看
        // Reset the idle handler count to 0 so we do not run them again.
        pendingIdleHandlerCount = 0;

        // While calling an idle handler, a new message could have been delivered
        // so go back and look again for a pending message without waiting.
        nextPollTimeoutMillis = 0;
    }
}

Looper.myQueue.addIdleHandler(new MessageQueue.IdleHanlder() {
   @Override
   public boolean queueIdle() {
       //do something
       return false; //false表示执行一次后移除，ture下次msg为空继续回调
   }
})

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

 public Handler(@Nullable Callback callback, boolean async) {
    ...
     mLooper = Looper.myLooper(); // 通过 Looper.mylooper静态方法获取当前线程的消息队列
     if (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 boolean sendMessageAtTime(@NonNull Message msg, long uptimeMillis) {
        MessageQueue queue = mQueue;
        ...//处理异常
        return enqueueMessage(queue, msg, uptimeMillis);
    }

    private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
            long uptimeMillis) {
        msg.target = this; // 这句非常重要，这里将 handler的赋值给了 msg.target，以便能让 handler来处理该消息
        ...
        return queue.enqueueMessage(msg, uptimeMillis); //让该消息入队列
    }

boolean enqueueMessage(Message msg, long when) {
    ...//异常处理
    synchronized (this) {
        ...//异常处理
        msg.markInUse();
        msg.when = when;
        Message p = mMessages;//获取当前消息队列
        boolean needWake; //是否要唤醒消息队列
        if (p == null || when == 0 || when < p.when) {
            // 当消息队列为空，或者当前消息需要立即执行，该msg为首条消息，且唤醒
            // New head, wake up the event queue if blocked.
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked; //设置阻塞唤醒
        } else { //正常插入消息到队列的常规case
            // Inserted within the middle of the queue.  Usually we don't have to wake
            // up the event queue unless there is a barrier at the head of the queue
            // and the message is the earliest asynchronous message in the queue.
            needWake = mBlocked && p.target == null && msg.isAsynchronous();
            Message prev;
            for (;;) {// 按照msg执行时间插入到对应的位置
                prev = p;
                p = p.next;
                if (p == null || when < p.when) {
                    break;
                }
                if (needWake && p.isAsynchronous()) {
                    needWake = false;
                }
            }
            msg.next = p; // invariant: p == prev.next
            prev.next = msg;
        }

        // We can assume mPtr != 0 because mQuitting is false.
        if (needWake) {// 假如需要唤醒，就立即唤醒
            nativeWake(mPtr);
        }
    }
    return true;
}

public void dispatchMessage(Message msg) {
    if (msg.callback != null) { //使用Handler.post(runnbale)调用
        handleCallback(msg);
     } else {
          if (mCallback != null) {//使用Handler(callback)构造
             if (mCallback.handleMessage(msg)) {
                    return;
                }
          }
       handleMessage(msg); //回调Handler:handleMessage处理
    }
}

public final boolean post(Runnable r){
   return  sendMessageDelayed(getPostMessage(r), 0);
}
private static Message getPostMessage(Runnable r) {
   Message m = Message.obtain();
   m.callback = r; //将runable 赋值给msg属性
   return m;
}