Android异步消息处理机制Handler

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

    @Override
    public void run() {
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
        }
        Looper.loop();
    }

说明：数据结构队列：单链表。从如下源代码中看出，是一个单项链表。

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;
            }
    }
}

问题一：无限循环？那会抛出异常的？没错，解决办法就是没有消息时阻塞。

问题二：如何阻塞呢？

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

无限循环追根溯源

汇编语言实现无限循环

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;//退出函数，loop()函数结束导致main函数结束。
            }
        }

    }
}

2.获取队列中的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;
    Handler target;
    public Message() {    }

    /***/
    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对象的代码写的非常好可以阅读学习学习