Android源码分析之Handler机制

Handler机制的作用：
1.UI更新
2.消息处理机制，可以用来进行异步通信

---

为何设计Handle机制？
主要是为了解决并发处理的问题，
如果在多个子线程直接更新主线程（UI线程）会导致界面更新混乱，那么如何保证更新同步？
如果引入加锁的话会产生性能下降的问题，故而参考windows消息处理机制，设计了Handle处理。
而使用Handle机制以异步通信的方式进行处理消息，且可以保证消息处理先后有序。

---

主要的相关类
framework/base/core/java/andorid/os/
- Handler.java
- Looper.java
- Message.java
- MessageQueue.java

主要作用
Message
1.消息实体，包含一个缓冲的消息池(链表结构)，持有一个Handler句柄，通过Handler发送消息到MessageQueue中。
2.构造消息的时候优先从池中取出，如果没有在构造，回收消息的时候，将其赋值为空，然后从池子里移除。

MessageQueue
1.消息存放的地方，一个链表维护要处理的消息，提供了enqueue，remove等从链表中存取消息的方法，next方法提取下一条message。
2.链表中的消息按照处理时间排序，在入队的时候做了处理。

Handler
1.创建时需要实现一个接口，其方法是handleMessage,此接口在Looper.loop调用handler.dispatchMessage时后处理此消息

2.Handler是Message的主要处理者，负责将Message添加到消息队列以及对消息队列中的Message进行处理

Looper
循环器，扮演Message Queue和Handler之间桥梁的角色，循环取出Message Queue里面的Message，并交付给相应的Handler进行处理

典型实例

class LooperThread extends Thread {
    public Handler mHandler;

    public void run() {
        Looper.prepare();//1. Looper初始化 
        mHandler = new Handler() {  //2.创建handler
            public void handleMessage(Message msg) {
                //TODO 定义消息处理逻辑. //3.实现消息处理的接口
            }
        };

        Looper.loop();  //4.启动loop循环
    }
}

这样定义完后，只要持有了此handler实例，就可以发送消息给此线程，之后消息会在handleMessage方法中得到处理。

跟进Looper分析
1.prepare方法分析

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

    private static void prepare(boolean quitAllowed) {
            //确保只创建一个Looper
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

可以看到prepare操作主要是对sThreadLocal进行设置。

这里的sThreadLocal是ThreadLocal类型，下面，先说说ThreadLocal。
ThreadLocal： 线程本地存储区（Thread Local Storage，简称为TLS），每个线程都有自己的私有的本地存储区域，不同线程之间彼此不能访问对方的TLS区域。

TLS常用的操作方法：
ThreadLocal.set(T value)：将value存储到当前线程的TLS区域
ThreadLocal.get()：获取当前线程TLS区域的数据
具体原理及作用另寻见Java多线程分析

2.分析Loop方法

    /**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
    public static void loop() {
            //1.获取当前线程的looper实例，确保已经初始化
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }

        //2.获取该looper持有的queue
        final MessageQueue queue = me.mQueue;

                //确保在权限检查时基于本地进程，而不是基于最初调用进程
        // Make sure the identity of this thread is that of the local process,
        // and keep track of what that identity token actually is.
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();

                //3.启动loop循环
        for (;;) {

                //3.1从队列中取出消息
            Message msg = queue.next(); // might block 可能会阻塞
            if (msg == null) {
                // No message indicates that the message queue is quitting.无消息则退出
                return;
            }

                        //默认为null，可通过setMessageLogging()方法来指定输出，用于debug功能
            // This must be in a local variable, in case a UI event sets the logger
            final Printer logging = me.mLogging;
            if (logging != null) {
                logging.println(">>>>> Dispatching to " + msg.target + " " +
                        msg.callback + ": " + msg.what);
            }

            final long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;

            final long traceTag = me.mTraceTag;
            if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
                Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
            }
            final long start = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            final long end;
            try {
            //3.2处理消息
                msg.target.dispatchMessage(msg);
                end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            } finally {
                if (traceTag != 0) {
                    Trace.traceEnd(traceTag);
                }
            }
            if (slowDispatchThresholdMs > 0) {
                final long time = end - start;
                if (time > slowDispatchThresholdMs) {
                    Slog.w(TAG, "Dispatch took " + time + "ms on "
                            + Thread.currentThread().getName() + ", h=" +
                            msg.target + " cb=" + msg.callback + " msg=" + msg.what);
                }
            }

            if (logging != null) {
                logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
            }

            // Make sure that during the course of dispatching the
            // identity of the thread wasn't corrupted.
            final long newIdent = Binder.clearCallingIdentity();//确保分发过程中identity不会损坏

            //3.3Message回收
            msg.recycleUnchecked();
        }
    }

可以看到这里loop中会先调用myloop,而myLoop，查看myLooper可看到其实其是通过sThreadLocal.get去获取的，那么sThreadLocal是何时set的呢？
搜索sThreadLocal.set可以发现其在prepare中进行了实现，这里我们通过注释也可以清楚的看到。所以这也就是为何要在loop方法前，必须先调用prepare进行初始化的原因。

可以看到此方法主要做了以下操作：
可以看到Loop会先用perpare进行初始化后，之后构建一个循环，循环处理从消息池中取出的消息，直到没有消息时退出循环
1.读取MessageQueue的下一条Message；
2.把Message分发给相应的target；
3.再把分发后的Message回收到消息池，以便重复利用。

MessageQueue分析
1.跟进 MessageQueue 的next方法

    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;
        //循环遍历链表取出一个timeOut消息
        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                Binder.flushPendingCommands();
            }
            //阻塞操作，当等待nextPollTimeoutMillis时长，或者消息队列被唤醒，都会返回
            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.
                    //当消息Handler为空时，查询MessageQueue中的下一条异步消息msg，则退出循环
                    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; //成功地获取MessageQueue中的下一条即将要执行的消息
                    }
                } else {
                    // No more messages.
                    nextPollTimeoutMillis = -1;
                }
                                //消息正在退出，返回null
                // 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.//没有idle handlers 需要运行，则循环并等待。
                    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.
            //只有第一次循环时，会运行idle handlers，执行完成后，重置pendingIdleHandlerCount为0.
            for (int i = 0; i < pendingIdleHandlerCount; i++) {
                final IdleHandler idler = mPendingIdleHandlers[i];
                mPendingIdleHandlers[i] = null; // release the reference to the handler//去掉handler的引用

                boolean keep = false;
                try {
                    keep = idler.queueIdle();//idle时执行的方法
                } 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.
            //重置idle handler个数为0，以保证不会再次重复运行
            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.
            //当调用一个空闲handler时，一个新message能够被分发，因此无需等待可以直接查询pending message.

            nextPollTimeoutMillis = 0;
        }
    }

1.nativePollOnce是阻塞操作，其中nextPollTimeoutMillis代表下一个消息到来前，还需要等待的时长；当nextPollTimeoutMillis = -1时，表示消息队列中无消息，会一直等待下去。具体分析见native层的handler机制分析。

2.IdleHandler接口表示当MessageQueue发现当前没有更多消息可以处理的时候则顺便干点别的事情的callback函数（即如果发现idle了，
那就找点别的事干）。callback函数有个boolean的返回值，表示是否keep。如果返回false，则它会在调用完毕之后从mIdleHandlers中移除。

3.当处于空闲时，往往会执行IdleHandler中的方法。
当nativePollOnce()返回后，next()从mMessages中提取一个消息。

enqueueMessage方法分析

    boolean enqueueMessage(Message msg, long when) {
                ...
        synchronized (this) {
            if (mQuitting) {
                    ...
                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;
            }
            //可以看到Message的消息管理是个链表形式，另外每次入队的时候都是按时间进行从小到大排序了的。
            // We can assume mPtr != 0 because mQuitting is false.
            if (needWake) {
                nativeWake(mPtr);
            }
        }
        return true;
    }

removeMessages方法分析

    void removeMessages(Handler h, int what, Object object) {
        if (h == null) {
            return;
        }

        synchronized (this) {
            Message p = mMessages;

            // Remove all messages at front.
            while (p != null && p.target == h && p.what == what
                   && (object == null || p.obj == object)) {
                Message n = p.next;
                mMessages = n;
                p.recycleUnchecked();
                p = n;
            }

            // Remove all messages after front.
            while (p != null) {
                Message n = p.next;
                if (n != null) {
                    if (n.target == h && n.what == what
                        && (object == null || n.obj == object)) {
                        Message nn = n.next;
                        n.recycleUnchecked();
                        p.next = nn;
                        continue;
                    }
                }
                p = n;
            }
        }
    }

可以看到MessageQueue维护了Message链表，提供了消息添加，移除，及获取下一个消息方法。保证了消息获取是同步的，且消息存放是有序的。

Handler类分析
1.Handler的构造

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

public Handler(Callback callback, boolean async) {
    //匿名类、内部类或本地类都必须申明为static，否则会警告可能出现内存泄露
    if (FIND_POTENTIAL_LEAKS) {
        final Class<? extends Handler> klass = getClass();
        if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                (klass.getModifiers() & Modifier.STATIC) == 0) {
            Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                klass.getCanonicalName());
        }
    }
    //必须先执行Looper.prepare()，才能获取Looper对象，否则为null.
    mLooper = Looper.myLooper();  //从当前线程的TLS中获取Looper对象
    if (mLooper == null) {
        throw new RuntimeException("");
    }
    mQueue = mLooper.mQueue; //消息队列，来自Looper对象
    mCallback = callback;  //回调方法
    mAsynchronous = async; //设置消息是否为异步处理方式
}

从Handler的构造函数来看，主要初始化的有Looper,MessageQueue,CallBack,

    public interface Callback {
        public boolean handleMessage(Message msg);
    }

可以看到Handler中的CallBack接口，其就是每次要创建Handler时需要实现的handleMessage消息，即消息处理的地方

2.消息分发
在Looper的Loop的循环中会调用msg.target.dispatchMessage进行处理，就是handler中的dispatchMessage方法。

    /**
     * Handle system messages here.
     */
    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

可以看到这里会调用handleMessage进行处理消息。

3.消息发送

    public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        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, uptimeMillis);
    }

可以看到消息发送其实就是调用将message发送到messageQueue中

Message分析
消息结构：

数据类型	成员变量	解释
int	what	消息类别
long	when	消息触发时间
int	arg1	参数1
int	arg2	参数2
Object	obj	消息内容
Handler	target	消息响应方
Runnable	callback	回调方法

创建消息方法分析

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

可以看到其优先从缓冲的池子里找，如果没有在构造一个消息

回收消息方法分析

    void recycleUnchecked() {
        // Mark the message as in use while it remains in the recycled object pool.
        // Clear out all other details.
        flags = FLAG_IN_USE;
        what = 0;
        arg1 = 0;
        arg2 = 0;
        obj = null;
        replyTo = null;
        sendingUid = -1;
        when = 0;
        target = null;
        callback = null;
        data = null;

        synchronized (sPoolSync) {
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }

可以看到回收时把消息的属性恢复成初始值后加入到消息缓冲池中。这样的好处是，当消息池不为空时，可以直接从消息池中获取Message对象，而不是直接创建，提高效率。

静态变量sPool的数据类型为Message，通过next成员变量，维护一个消息池；
静态变量MAX_POOL_SIZE代表消息池的可用大小；消息池的默认大小为50。

简单在总结下就是：
1.Handler调用sendMessage发送消息，发送Message到MessageQueue中
2.Looper的Loop循环调用queue.next()获取MessageQueue中的消息,
3.Message找到handler处理handleMessage

本文参考了以下博客：
GitYuan的Android消息机制1-Handler(Java层)
Jamy Cai的Android中的Handler的机制与用法详解

本文分析的比较简陋，有需要深入理解的推荐精读如下博客：
Handler机制原理（一）宏观理论分析与Message源码分析