Handler机制

通过Handler发送Message到其他线程，首先要在主线程中创建Looper实例，然后启动Looper循环机制；

Looper.prepareMainLooper();
Looper.loop(); //启动looper循环

在looper中，在做无限循环MessageQueue中Message

 public static void loop() {
        for (;;) {
            //从消息池中获取数据
            Message msg = queue.next(); 
            //如果等于null,就是消息池无数据
            if (msg == null) {
                return;
            }
            //将拿取的数据发送给指定的handler
            msg.target.dispatchMessage(msg);
        }
}

现在我们在主线程中创建一个handler，然后发送一个消息Message

               new Handler(){
                    @Override
                    public void handleMessage(Message msg) {
                        super.handleMessage(msg);
                        
                    }
                }.sendMessageDelayed(new Message(),200);

然后我们看看handler中sendMessageDelayed()方法

 public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        //SystemClock.uptimeMillis() 是开机时间毫秒数
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

最后调用该方法：

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

该消息将要打算放入消息池中，

boolean enqueueMessage(Message msg, long when) {
       
        synchronized (this) {
           
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            //如果when时间是0，就直接将message放入池中，修改needWake值
            if (p == null || when == 0 || when < p.when) {
            
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                //如果when不是0，也就是有延迟的话
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;
                //该消息就会堵塞在循环中，直到延迟时间够了，就将Message放入消息池中
                for (;;) {
                    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;
            }

           //是否唤醒
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

总结：

如果发送一个延迟消息的话，该消息会通过for循环阻塞线程池，直到时间结束了，才会跳出该for，然后将该消息放入消息池中，然后唤醒线程。