Handler源码解析

1.概述

Handler一般在Android的UI线程和子线程间通信使用,之前我们在分析AsyncTask源码的时候就发现其实她的内部是Handler和Thread的一个组合,子线程做耗时的计算任务,Handler负责传递和接收结果。AsyncTask的源码解析请移步到我的另一篇文章AsyncTask源码分析

2.用法

我们这里简单回顾一下Handler的用法:

创建一个Handler用来接收消息

Handler handler = new Handler(){
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            Bundle bundle = msg.getData();
            Logger.d(TAG,bundle.getString("Content"));
        }
};

发送消息

Thread myThread  = new Thread(){
        @Override
        public void run() {
            super.run();
            Message message = handler.obtainMessage();
            message.what = 111;
            Bundle bundle = new Bundle();
            bundle.putString("Content","内容");
            message.setData(bundle);
            handler.sendMessage(message);
        }
    };

3.源码相关解析

消息机制一般有是三个主要组成部分:

1.消息发送者;

2.消息队列;

3.消息处理循环

运行机制:

消息发送者通过某种方式,将消息发送到某个消息队列,同时存在一个消息处理循环,不断的从消息队列中取出消息进行处理。

Android中的Handler消息处理主要由五个部分组成:
Message:

Message是线程中实实在在传递的消息,用于线程间交换数据,有四个常用字段,what、arg1、arg2、obj,前三者是int型,用于int型数据的传递,好处是轻量,obj可以传递稍复杂的object对象,但是请注意数据量不要太大;

Handler:

发送和处理消息,具体是怎么处理的待会儿再讲;

MessageQueue

消息队列,存放Handler发送过来的Message,它是一个单链表结构,消息会被一个接一个的处理,每个线程只存在一个消息队列

Looper

消息都存在MessageQueue中,怎么取出来呢?Looper中的loop()方法是一个死循环,Looper通过调用这个方法,只要消息队列中存在消息,就会一个接一个的取出来传递到Handler的handleMessage()中,当然的每个线程都只有一个一个Looper对象。

ThreadLocal

为了保证每个线程只有一个Looper对象,我们使用ThreadLocal来存储Looper,它的内部做了并发的相关处理,保证Looper的唯一性

通过sendMessage()方法我们找到实际调用的是MessageQueue中的

boolean enqueueMessage(Message msg, long when) {
        //msg.target是handler对象  
        if (msg.target == null) {
            throw new IllegalArgumentException("Message must have a target.");
        }
        //Message
        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 {
                // 新消息会插入到链表的内部,一般情况下,这不需要调整唤醒时间。
                // 但还必须考虑到当表头为“同步分割栏”的情况
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                Message prev;
                for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                    // 说明即便msg是异步的,也不是链表中第一个异步消息,所以没必要唤醒
                    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;
    }

这段代码的意思是:在链表的合适位置插入Message节点。链表是按照时间排序的,这段代码主要是在比对Message的when信息,消息链表的第一个节点对应着最先被处理的消息,如果Message被插入到链表的头部,意味着队列的最近唤醒时间也跟着改变,needWake被置为true,进入nativeWake方法。nativeWake()方法对应的是c++层,我们暂不做深入研究。
接下来我们看消息循环Looper的loop()方法。我们知道程序都有相应的入口,Activity是怎么样的消息驱动机制呢,在ActivityThread的main方法中我们发现是调用了 Looper.prepareMainLooper()创建主线程的Looper和MessageQueue,并通过 Looper.loop()开启消息循环。

public static void prepareMainLooper() {
            prepare(false);
            synchronized (Looper.class) {
                if (sMainLooper != null) {
                    throw new IllegalStateException("The main Looper has already been prepared.");
                }
                sMainLooper = myLooper();
            }
}

内部调用了prepare(false)和myLooper()

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

sThreadLocal保存了一个Looper对象,首先判断是否已经存在Looper对象,ThreadLocal是并发安全的,同时保证么个线程只有一个Looper对象。
我么看一下Looper的构造函数

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

创建Looper的同时创建了一个MessageQueue消息队列和保存了当前线程,quitAllowed表示消息队列是否可以退出。

prepareMainLooper()中调用的myLooper()是什么呢?看源码启示是从sThreadLocal中取出Looper。

Looper的初始化完成了,接下来是另一个重要的方法Looper.loop():

public static void loop() {
        final Looper me = myLooper();
        ...
        final MessageQueue queue = me.mQueue;

        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();

        for (;;) {
            Message msg = queue.next();
            if (msg == null) {
                return;
            }
            ...
            msg.target.dispatchMessage(msg);
            ...
            msg.recycleUnchecked();
        }
    }

逻辑比较简单,通过一个死循环不断的从MessageQueue的next()方法中取出消息,然后调用msg.target.dispatchMessage(msg),再然后回收该消息,如果消息为空,继续循环,直到有新消息为止,这是一个阻塞操作,msg.target上文我们讲过就是handler对象。

public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
               if (mCallback.handleMessage(msg)) {
                     return;
                 }
            }
            handleMessage(msg);
        }
}

msg.callback是什么呢,点击查看到Handler的构造函数我们看到callback是作为参数传入的,我们在调用Handler的post方法的时候传的是Runnable对象。

我们来看看我们经常会用到的两个方法runOnUiThread和View的postDelayed

public final void runOnUiThread(Runnable action) {
            if (Thread.currentThread() != mUiThread) {
                mHandler.post(action);
            } else {
                action.run();
            }
}
public boolean postDelayed(Runnable action, long delayMillis) {
            final AttachInfo attachInfo = mAttachInfo;
            if (attachInfo != null) {
                return attachInfo.mHandler.postDelayed(action, delayMillis);
            }
            ViewRootImpl.getRunQueue().postDelayed(action, delayMillis);
            return true;
}

可以看到都是执行了主线程的run()方法。

讲到这里Handler的通讯原理基本上讲完了,但是其实还有一个很重要的地方没有说到,就是MessageQueue的next()方法。MessageQueue是怎么一个接一个的取消息呢,我们来看:
对消息队列而言,在摘取消息时还要考虑更多技术细节。

消息队列它应该具有以下特点:

1.当消息队列中没有新消息时,我们应该使之阻塞,而不应该继续下面的一系列的操作;

2.队列里的消息应该按照时间先后顺序排列,最先到时的消息会放在队列的头部,时间这里指的是mMessage.when,依次排序;

3.阻塞时间最好能精确,如果暂时没有合适的消息可以摘取时,要考虑链表的消息首个节点将什么时间到,这个消息节点到当前的时间差,就是我们要阻塞的时间;

4.有些时候我们可能希望在消息队列进入阻塞的时候做一些动作,这些动作称为idle动作,我们需要兼顾处理这些idle动作。

MessageQueue的next()函数如下:

Message next() 
{
    int pendingIdleHandlerCount = -1; // -1 only during first iteration
    int nextPollTimeoutMillis = 0;
    
    for (;;) {
        . . . . . .
        nativePollOnce(mPtr, nextPollTimeoutMillis);    // 阻塞于此
        . . . . . .
            // 获取next消息,如能得到就返回之。
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;  // 先尝试拿消息队列里当前第一个消息
            
            if (msg != null && msg.target == null) {
                // 如果从队列里拿到的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 (false) Log.v("MessageQueue", "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 (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;
            }
        . . . . . .
        // 处理idle handlers部分
        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("MessageQueue", "IdleHandler threw exception", t);
            }

            if (!keep) {
                synchronized (this) {
                    mIdleHandlers.remove(idler);
                }
            }
        }
        
        pendingIdleHandlerCount = 0;
        nextPollTimeoutMillis = 0;
    }
}

当MessageQueue的定时机制触发后,会判断这条消息是否真的到时,如果到时,则直接返回这个Message,如果没有到时,则计算一个等待时间,继续for循环继续调用nativePollOnce(mPtr, nextPollTimeoutMillis),进入阻塞状态,等待指定的等待时间。

next()中的Idle Handler,我们前面说过,在消息队列阻塞之前,我们可能希望做一些其它的操作,比如垃圾回收,在ActivityThread中我们看一下GcIdler的定义:

final class GcIdler implements MessageQueue.IdleHandler {
    @Override
    public final boolean queueIdle() {
        doGcIfNeeded();
        return false;
    }
}

Handler的消息机制我们讲完了,还有一些细节我们没有涉及,比如我们发现源码里面调用了native层的方法、比如同步分隔栏的原理,如果你想继续深入的研究下去,你可以去深究这些代码,下面的参考博文,讲的很详细,其实我也是查看源码,然后有一些不懂的地方去对照着这篇博文去理解,这里感谢这篇文章的博主。

参考:

聊一聊Android的消息机制

推荐阅读更多精彩内容