Android Handler源码解析

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/guiying712/article/details/53412281

版权声明:本文为博主原创文章,欢迎大家转载!

转载请标明出处: http://blog.csdn.net/guiying712/article/details/53412281,本文出自:【张华洋的博客】


Handler允许我们发送和处理Message , 还可以将Runnable对象关联到线程的MessageQueue;每个Handler实例都会与一个线程以及线程的消息队列相关联。当我们创建一个新的Handler后,这个Handler就会与它创建所在的线程和线程的消息队列绑定,它将Message 传送到消息队列,并执行从MessageQueue中出列的消息。

Handler主要有两个用途:

(1) 调度 messages和runnables,以便在未来的某个时间点执行;

(2) 将一个action发送到另一个线程排队等待执行,这种用法大家应该使用的最多,就是在子线程通知主线程更新 UI。

Handler主要有以下两种使用方式:

class SnackbarManager {

    ...
    private final Handler mHandler;

    private SnackbarManager() {
        ...
        mHandler = new Handler(Looper.getMainLooper(), new Handler.Callback() {
            @Override
            public boolean handleMessage(Message message) {
                switch (message.what) {
                    case MSG_TIMEOUT:
                        handleTimeout((SnackbarRecord) message.obj);
                        return true;
                }
                return false;
            }
        });
    }

以及内部类的方式:

class AlarmManagerService extends SystemService {

    ...
    final AlarmHandler mHandler = new AlarmHandler();

    private class AlarmHandler extends Handler {
        public static final int ALARM_EVENT = 1;

        public void handleMessage(Message msg) {
            switch (msg.what) {
                case ALARM_EVENT: {
                    ...
                    break;    
                default:
                    // nope, just ignore it
                    break;
            }
        }
    }

在文章的开始我们已经讲过,Handler主要用来发送和处理Message,在上面的代码中我们已经有了处理Message的逻辑,那么消息是怎么被传送到Handler中处理消息的地方呢?

因为Handler即可以处理Message又可以处理Runnable,所以消息调度主要有如下几个方法:

{@link #post},
{@link #postAtTime(Runnable, long)},
{@link #postDelayed}
{@link #sendEmptyMessage},
{@link #sendMessageAtTime},
{@link #sendMessageDelayed} .

其中带 post 的方法都是用来发送Runnable,而带 send 方法则是用来发送Message的,实质上 post 方法内部也是调用 send 方法来调度Runnable的;我们来看下面的方法:

public final boolean post(Runnable r){
       return  sendMessageDelayed(getPostMessage(r), 0);
    }

 public final boolean postAtTime(Runnable r, long uptimeMillis){
        return sendMessageAtTime(getPostMessage(r), uptimeMillis);
    }

 public final boolean postAtTime(Runnable r, Object token, long uptimeMillis){
        return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
    }

我们可以看到每个post方法中都调用了send方法将Runnable添加到消息队列中,getPostMessage就是用来将postf方法中的入参 Runnable 转换成 Message 类型 的方法;


 private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }

我们可以看到 Message 中持有的变量 callback 引用就是一个Runnable对象。

我们再看下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);
        }
    }

在getPostMessage方法中,我们post 的 Runnable对象被赋值到 Message 的 callback 引用中了,因此处理这种消息是通过handleCallback(msg)来处理的;而 send 的 Message对象 是通过 handleMessage(msg) 来处理的。

不管是 post 方法还是 send 方法,最终都会调用 enqueueMessage() 方法,将Message添加到消息队列中。


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

在调用 enqueueMessage方法时,会传入 Message 和它要入队的MessageQueue ,在方法内部,入参Message 会将当前的 Handler对象赋值到自己的 变量 target ,这样每一个Message都持有了发送Message的Handler对象。然后在通过MessageQueue 的 enqueueMessage方法,将Message送入这个MessageQueue 中排队。

我们先不着急进入MessageQueue 的enqueueMessage方法中。首先我们需要考虑下Handler中的MessageQueue 是从哪来的?不管是post 和 send 方法中, 我们都没有传入过MessageQueue 。

通过查看代码我们可以发现每个send方法中都有 MessageQueue queue = mQueue,那么mQueue又是在哪里赋值的呢?

在Handler类中,主要有这么几个成员变量:


    final Looper mLooper;
    final MessageQueue mQueue;
    final Callback mCallback;
    final boolean mAsynchronous;
    IMessenger mMessenger;

其中MessageQueue 就是消息队列,Callback接口使用来处理消息的,IMessenger 是用来跨进程通信的,mAsynchronous如果为true,意味着message将不再受Looper的同步机制限制,接下来Handler机制中非常重要的角色Looper ,而我们的MessageQueue 就是通过 looper.mQueue 获取到的。

Looper是用于在线程中运行消息循环的类,默认情况下,线程中没有与之关联的 消息循环(Looper)。Handler中主要有两种方式获得Looper ,一种是通过 Looper.myLooper() 获得Looper 对象,还有一种方式就是在 创建Handler对象是传入一个Looper对象。但是不管哪种方式,都是通过 Looper.prepare() 来创建Looper 对象的,一旦创建后,这个消息循环就会运行在它被创建的那个线程中,然后使用 loop() 来处理消息,直到这个消息循环停止;

在prepare方法中,我们可以看到Looper类中使用了 ThreadLocal来保存Looper对象。

public final class Looper {

    // sThreadLocal.get() will return null unless you've called prepare().
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();


    private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }

     private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }


    public static Looper myLooper() {
        return sThreadLocal.get();
    }

    public static MessageQueue myQueue() {
        return myLooper().mQueue;
    }

在prepare方法中,检查当前线程中有没有Looper对象,如果有就抛出异常(每个线程中只能创建一个循环),如果没有,就 new 一个Looper对象,而MessageQueue对象就是在Looper构造函数中创建的,Handler中持有的MessageQueue对象也正是Looper中的MessageQueue对象。创建的Looper对象被保存到了ThreadLocal中,ThreadLocal在保存Looper时,会先获取当前Thread线程对象,然后通过Thread对象 获取到 Thread对象持有的ThreadLocalMap,并以当前ThreadLocal 对象做为key,以Looper对象作为 value 保存到ThreadLocalMap中。因此我们就可以通过 ThreadLocal的get() 方法获取到保存到 当前线程的ThreadLocalMap 中的 Looper对象。

接下来我们需要重点分析下Looper类的 loop() 方法。


   /**
     * Run the message queue in this thread. Be sure to call
     * {@link #quit()} to end the loop.
     */
    public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;

        ...

        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }
           ...

            try {
                msg.target.dispatchMessage(msg);
                ...
            } 
            ...

            msg.recycleUnchecked();//这个消息的使命已经完成,回收这个消息以便通过 obtain() 再次使用;
        }
    }

我在 loop() 方法中只保留了关键信息,我们可以看到当调用了 loop() 方法后,首先需要获取到当前线程中保存的 Looper对象,如果这个Looper对象为空就会抛出异常(没有在当前线程中调用Looper.prepare() 创建 Looper),然后获取到Looper持有的 MessageQueue ,之后便进入了一个无限循环中,每次进入循环都取出一条消息,如果没有消息则阻塞。在前面我们已经分析过,在 Handler 的 enqueueMessage() 方法中有一行代码 msg.target = this,将Handler 赋值到 Message的target 变量中,因此我们就可以通过 msg.target 获取到发送消息的Handler,然后在调用这个Handler的dispatchMessage()方法,将消息分发出去,由于这个方法我们已经在前面分析过,就不再深入了。

另外我们是可以通过 调用 Looper的 quit()方法 退出消息循环的,当然 quit()方法中实际上是 通过 Looper持有的MessageQueue对象的 quit() 方法退出的;

quit 退出机制 有两种,分为 普通退出和安全退出。他们的区别在于,普通退出 会导致 loop(循环) 直接终止,不会再处理消息队列中的任何消息,这时候你调用 Handler#sendMessage(Message)方法会直接返回 false,使用这个方法会造成一些消息不会被 传送到 Handler 中 处理 。而安全退出则 会等到消息队列中的所有消息都已经被 交付到 Handler处理后才会 终止 loop 循环。

讲到这里我们基本可以勾勒出整个Handler消息机制的架构了:

Handler消息机制

不过我们现在还有一个重要的地方没有分析,那就是MessageQueue。我们在前面讲到了 通过MessageQueue 的 enqueueMessage方法,将Message送入这个MessageQueue 中排队,那么现在我们就深入到 MessageQueue 的 enqueueMessage() 方法中去。


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持有的Handler是不是为空,如果为空就抛出异常(消息必须有一个目标Handler-用来分发和处理消息)。

然后判断这个消息是否在使用中 isInUse(消息从 enqueue 到 被回收这个阶段就是 FLAG_IN_USE),如果已经在使用中了,也会抛出异常(这个消息已经在使用中)。

接着判断这个MessageQueue 是否正在退出中,如果 MessageQueue 正在退出中,就回收这个Message,并返回 false。

如果前面判断都通过后,就将这个Message标记为 FLAG_IN_USE。

MessageQueue 类中的 成员变量 mMessages 是 loop() 方法中当前拿到的Message对象, enqueueMessage()方法中需要判断 当前 loop循环 是 否在阻塞中,如果处于阻塞中就需要唤醒这个loop 循环 处理 新加入的消息。另外 消息队列 是一个单链表,所以每个消息都需要记录 next位置的 消息。

到这里,整个Handler源码就算是分析完了,下篇将会分析在Looper类中使用到的 ThreadLocal 类。

没有更多推荐了,返回首页