简单来说就是在线程中开启无限循环，处理队列中的消息。

说明：其实不应该描述为队列。队列：先进先出。从如下源代码中看出，是一个单项链表。

MessageQueue最终类，不可被继承。

构造函数默认修饰符，只能在本包中实例化MessageQueue对象。

MessageQueue.java{        boolean enqueueMessage(Message msg, long when) {              Message p = mMessages;            if (p == null || when == 0 || when < p.when) {                // New head, wake up the event queue if blocked.                msg.next = p;                mMessages = msg;                needWake = mBlocked;            } else {                Message prev;                for (;;) {                    prev = p;                    p = p.next;                    if (p == null || when < p.when) {                        break;                    }                }                msg.next = p; // invariant: p == prev.next                prev.next = msg;            }    }}

问题一：无限循环？那会抛出异常的？没错，解决办法就是MessageQueue中没有Message对象时休眠。

问题二：如何休眠呢？

问题三：又是如何唤醒线程的呢？

无限循环追根溯源

汇编语言实现无限循环

fin:    HLT    JMP fin

C语言实现无限循环

fin:    /**这里想写HLT，但是C语言不能使用HLT*/    goto fin;    //这里是是有分号的

Android/Java实现无限循环

for( ; ; ) {}

1.线程中开启无限循环

Looper.java

Looper.java{    public static void loop() {        for(;;){            Message msg = queue.next();//可能会阻塞            if (msg == null) {                return;//退出函数            }        }    }}

2.消息队列（MessageQueue）push Message对象

MessageQueue.java{    synchronized (this) {        //Try to retrieve the next message.  Return if found.(试图获取下一条消息，如果有则返回)        Message next() {            //Handler target            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());//        }    }}Message.java{    int flags;    //<
    <位运算符，左移，左边的数值想左移动一位。 这里就是0001移动一位后变成0010 static final int flag_asynchronous="1">
     << 1;    public boolean isAsynchronous() {        //&位运算符，位与，位相同结果位1。        //flag & 0010        return (flags & FLAG_ASYNCHRONOUS) != 0;    }}
    

2.1.判断处理Message对象的的时间

MessageQueue.java{    Message next() {        final long now = SystemClock.uptimeMillis();        synchronized(this) {            if (msg != null) {                if (now < msg.when) {                    // 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);                                   }            }        }      }}Message.java{    long when;    /***/    void recycleUnchecked() {       when = 0;    }    /**回收*/    public void recycle() {        recycleUnchecked();    }        public long getWhen() {        return when;    }}

2.2.MessageQueue队列如何组织Message对象的

Message.java{   //以链表的形式存储Message对象    Message next;    private static Message sPool;    private static int sPoolSize = 0;    private static final int MAX_POOL_SIZE = 50;    /**     *返回一个新的消息实例从全球池。在许多情况下,避免分配新对象。     */    public static Message obtain() {        synchronized (sPoolSync) {            if (sPool != null) {                Message m = sPool;                sPool = m.next;                m.next = null;                m.flags = 0; // clear in-use flag                sPoolSize--;                return m;            }        }        return new Message();    }    //<6>    public void recycle() {        if (isInUse()) {            if (gCheckRecycle) {                throw new IllegalStateException("This message cannot be recycled because it "                        + "is still in use.");            }            return;        }        recycleUnchecked();    }    //<7>    void recycleUnchecked() {        synchronized (sPoolSync) {            if (sPoolSize < MAX_POOL_SIZE) {                next = sPool;                sPool = this;                sPoolSize++;            }        }    }}MessageQueue.java{    /**     *     *     *<5>线程中调用到这个函数时是重点！重点！重点！     *     */    boolean enqueueMessage(Message msg, long when) {        //同步，在一个线程中        synchronized (this) {            if (mQuitting) {                msg.recycle();            }        }    }}Handler.java{    //<1>    public final boolean sendMessage(Message msg)    {        return sendMessageDelayed(msg, 0);    }    //<2>    public final boolean sendMessageDelayed(Message msg, long delayMillis)    {        if (delayMillis < 0) {            delayMillis = 0;        }        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);    }    //<3>    public final boolean sendMessageAtFrontOfQueue(Message msg) {        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, 0);    }    //<4>    private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {        msg.target = this;        if (mAsynchronous) {            msg.setAsynchronous(true);        }        return queue.enqueueMessage(msg, uptimeMillis);    }}

3.阻塞线程

MessageQueue.java

MessageQueue.java{    Message next() {        for(;;) {            //刷新等待命令，猜测这里实现的就是线程阻塞，也是一个本地方法            //查看注释：可能会阻止很长一段时间。            Binder.flushPendingCommands()            //这里调用了一个本地方法，方法名称上看--本地检测一次，检测什么呢？            nativePollOnce(ptr, nextPollTimeoutMillis);        }    }}

看到调用本地方法，是不是有种山穷水尽的嗡嗡感觉。其实看看上面描述的c语言无限循环代码大致就了解库中无非也就是这么实现的。

队列中有Message对象，但是处理该对象的时间未到，计算阻塞的时间。

MessageQueue.java{    Message next() {        for(;;) {            //nextPollTimeoutMillis阻塞时间            nativePollOnce(ptr, nextPollTimeoutMillis);            if (msg != null) {                if (now < msg.when) {                    // 计算线程阻塞时间                    nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);                }            }        }    }}

队列中没有Message对象，则无限期的阻塞直到有Message对象插入队列中时唤醒线程。

MessageQueue.java{    Message next() {        for(;;) {            //nextPollTimeoutMillis休眠时间            nativePollOnce(ptr, nextPollTimeoutMillis);            synchronized (this) {            Message msg = mMessages;            if (msg != null && msg.target == null) {                        }            if (msg != null) {                        } else {                // No more messages.                //-1代表无限期的休眠                nextPollTimeoutMillis = -1;              }        }    }    boolean enqueueMessage(Message msg, long when) {        synchronized (this) {            boolean needWake;            if (needWake) {                //唤醒线程                nativeWake(mPtr);            }                   }    }}

获取Message对象的代码写的非常好可以阅读学习学习

ActivityThread.java

public static void main(String[] args) {        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"));        }        Looper.loop();        throw new RuntimeException("Main thread loop unexpectedly exited");    }