Android Handler消息机制

Android消息机制主要是指Handler,MessageQueue和Looper的工作过程。

一、首先我们就来说说为什么Android会提供这个功能？

       这是因为Android规定访问UI只能在主线程中进行，如果在子线程中访问UI,程序就会报错。也正是由于这个原因导致我们必须在主线程中访问UI。但是Android又不建议在主线程中进行耗时操作，否则会导致程序无响应也就是ANR。而Hndler出现的原因，也主要是解决在子线程中无法访问UI的矛盾

       再说下为什么系统不允许在子线程中访问UI？这是因为Android的UI线程是线程不安全的。

二、Handler的工作过程
       当Handler创建完成之后，这时候其内部的Looper以及MessageQueue就可以和Handler一起协同工作了。

1.首先Handler先通过send方法发生一个消息。
2.当Handler的send方法被调用时，它会调用MessageQueue的enqueueMessage方法，MessageQueue的enqueueMessage方法会将这个消息放入到消息队列中。
3.然后Loopler发现有新消息到来时就会处理这个消息。
4.最后Handler的HandlerMessage方法就会被调用。

具体流程可以用下面的图来表示

三、Android消息机制分析

3.1消息队列的工作原理

       消息队列在Android中指的是MessageQueue，MessageQueue主要包含插入和读取两个操作。而读取和插入对应的方法分别为enqueueMessage和next。尽管MessageQueue叫消息队列，但是它内部实现并不是用的队列，实际上它内部是通过单链表来维护消息列表，原因是因为单链表在插入和删除上比较有优势。

    boolean enqueueMessage(Message msg, long when) {        if (msg.target == null) {            throw new IllegalArgumentException("Message must have a target.");        }        if (msg.isInUse()) {            throw new IllegalStateException(msg + " This message is already in use.");        }        synchronized (this) {            if (mQuitting) {                IllegalStateException e = new IllegalStateException(                        msg.target + " sending message to a Handler on a dead thread");                Log.w(TAG, e.getMessage(), e);                msg.recycle();                return false;            }            msg.markInUse();            msg.when = when;            Message p = mMessages;            boolean needWake;            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 {                // 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 (;;) {                    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;    }

上面是enqueueMessage方法的源码，它主要的操作就是单链表的插入操作。

Message next() {        // Return here if the message loop has already quit and been disposed.        // This can happen if the application tries to restart a looper after quit        // which is not supported.        final long ptr = mPtr;        if (ptr == 0) {            return null;        }        int pendingIdleHandlerCount = -1; // -1 only during first iteration        int nextPollTimeoutMillis = 0;        for (;;) {            if (nextPollTimeoutMillis != 0) {                Binder.flushPendingCommands();            }            nativePollOnce(ptr, 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) {                        // 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;                        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;                    }                } else {                    // 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.                if (pendingIdleHandlerCount < 0                        && (mMessages == null || now < mMessages.when)) {                    pendingIdleHandlerCount = mIdleHandlers.size();                }                if (pendingIdleHandlerCount <= 0) {                    // No idle handlers to run.  Loop and wait some more.                    mBlocked = true;                    continue;                }                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);                    }                }            }            // 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;        }    }

上面是next方法的源码，我们可以发现next方法是一个无限循环的方法，如果消息队列中没有消息，那么next方法就会一直阻塞，如果有新的方法到来时，next方法就会返回这个消息并将其从单链表中移除

3.2Looper工作原理

       Looper在消息机制中它会不停的从MessageQueue中查看是否有新消息，如果MessageQueue中有新消息就会立刻处理，否则就会一直阻塞在那里。

Looper有一个最重要的方法就是loop方法，只有调用了loop方法以后，消息循环才会真正起作用，而Looper的loop方法的工作过程也很好理解，他和MessageQueue的next方法相似都是for（；；）的一个死循环，唯一跳出循环的方式是MessageQueue的next方法返回null，当Loop的quit方法被调用时，Looper就会调用MessageQueue的quit或者quitSafely方法来通知消息队列退出，当消息队列被退出时MessageQueue的next方法就会返回null，而如果MessageQueue的next方法返回了新消息Looper就会处理这条消息。

不知道大家在使用Handler的时候，如果有时候我们在子线程中使用Handler，那么就会报错，这是为什么呢？
       原因就是Handler工作需要Looper，如果没有Looper的线程就会报错，所以我们在子线程中使用Handler就需要创建Looper，我们可以通过Looper.prepare（）方法创建一个Looper对象，然后通过Looper.loop（）方法来开启消息循环，如下所示

    new Thread(){            @Override            public void run() {                super.run();                //创建Looper                Looper.prepare();                Handler hander = new Handler();                //开启消息循环                Looper.loop();            }        };

上面代码就是在子线程中创建一个Looper然后开启消息循环
那么有人会问为什么我们在主线程中使用Handler的过程中，我们没有创建Looper，但是使用Handler确可以正常使用呢？因为Looper除了提供prepare方法外还提供了prepareMainLooper方法，Android在主线程中已经处理了Looper，我们可以通过getMainLooper方法在任何地方获取到主线程的Looper，然后就可以使用quit方法退出Looper，这个是可以处理Handler中的内存泄漏问题的.

3.3Handler工作原理

Handler的工作主要包含消息的发送和接收过程，

Handler的消息发送：Handler消息发送可以通过post的一系列方法或者send的 一系列方法来实现，post的一系列方法最终通过send的一系列方法来实现，Handler的消息发送过程仅仅是向消息队列插入一条消息，MessageQueue的next方法就会将这条消息返回给Looper，然后Looper处理这条消息

Handler的消息处理：这里使用网上的一张状态图很好理解

好了这就是所有的Handler消息机制