阅读源码理解Handler机制

Handler机制作为Android面试重要考点，以前笔者都是参考别的优秀博客来了解，大致能够清楚是怎么一回事。然而在不依赖博客的情况下，就只有自己去阅读源码了。作为Android开发，Android源码就是解决问题的源头泉眼。Handler机制涉及的类比较少，代码量相对于庞大的AMS、WMS那些真是如小菜一碟了。Handler机制真正研究起来不需要花很多的时间，不过卡在某个点这种事情也经常发生。希望笔者写的这一篇可以帮助部分读者打通那些卡住的点。

Handler机制涉及的主要的类有Handler、Looper、MessageQueue和Message。

Handler类

较为常见的是在Activity中声明一个Handler对象出来，这个Handler是主线程的Handler。

public class XXXActivity extends Activity {
	……
	private Handler mHandler = new Handler() {
		@Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            // 处理返回的消息
            if( msg.what == 1 ){
				……
			}
			……
        }
	};
	……
	    @Override
    protected void onDestroy() {
        super.onDestroy();
        mHandler.removeCallbacksAndMessages(null);// 防止因Handler引起的内存泄漏
    }
}

Handler的构造方法：

    /**
     * Default constructor associates this handler with the {@link Looper} for the
     * current thread.
     *
     * If this thread does not have a looper, this handler won't be able to receive messages
     * so an exception is thrown.
     */
	// 平时我们在主线程使用的new一个Handler就是使用这个构造
    public Handler() {
        this(null, false);
    }

	public Handler(Callback callback, boolean async){
	……

		mLooper = Looper.myLooper();
		If(mLooper == null){	// 在主线程中不会执行到这里，因为主线程开启时已经绑定了Looper了
			throw new RuntimeException();
		}
		mQueue = mLooper.mQueue;  // Handler的Queue对象与它的Looper对象的mQueue绑定在了一起
		mCallback = callback;
		mAsynchronous = async;
}

主线程开启时Looper被绑定的代码：
ActivityThread:

public static void main(String[] args){
	……
	Looper.prepareMainLooper();//绑定主线程Looper
	……
	Looper.loop();//轮询开始，因为有这句，所以我们在主线程中不需要调用Looper.loop()了，在子线程中实例化Handler对象，需要调用这句话
	throw new RuntimeException(“Main thread loop unexpectedly exited”);
}

来看一下Looper的prepareMainLooper方法和与它相关的方法，loop方法是重头戏，先不那么快讲。
Looper：

    /**
     * Initialize the current thread as a looper, marking it as an
     * application's main looper. The main looper for your application
     * is created by the Android environment, so you should never need
     * to call this function yourself.  See also: {@link #prepare()}
     * 这个方法初始化了应用的main Looper,不应该由开发者调用。调用后通过ThreadLocal的性质将主线程和这个Looper绑定，这个Looper就是主线程的Looper
     */
    public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }

	private static void prepare(boolean quitAllowed){
		if(sThreadLocal.get() != null){	// ThreadLocal类中get方法的作用是获取属于当前线程的变量的副本
			throw new RuntimeException("Only one Looper may be created per thread");
		}
		sThreadLocal.set(new Looper(quitAllowed)); // 当前线程和Looper对象绑定在一起，线程为键，Looper对象为值
	}

    /**
     * Return the Looper object associated with the current thread.  Returns
     * null if the calling thread is not associated with a Looper.
     */
    public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

    /**
     * Return the {@link MessageQueue} object associated with the current
     * thread.  This must be called from a thread running a Looper, or a
     * NullPointerException will be thrown.
     */
    public static @NonNull MessageQueue myQueue() {
        return myLooper().mQueue;
    }

简单介绍Looper类

• 持有静态的 ThreadLocal 对象

Static final ThreadLocal< Looper > sThreadLocal = new ThreadLocal< Looper >();

上面代码的注释中解释了一下ThreadLocal存储对象的方式：以线程作为键值来存储对象。它就是Handler机制能在线程中切换的关键因素。因此值得再强调一下。
假设线程1 存储 1，线程2 存储 2，线程3 存储 3……，在线程1使用 ThreadLocal对象取值时（调用sThreadLocal.get()），得到 1，在线程2使用ThreadLocal对象取值时，得到2……。
同理可以推广到对象，假设主线程存储Looper对象0，线程1存储Looper对象1，线程2存储Looper对象2，线程3存储Looper对象3……这样的话我们在主线程就能取到Looper对象0了，与其他线程的Looper对象不产生混淆干扰。

• 持有MessageQueue对象
  Looper对象一般是通过它的静态方法prepare，每个Looper对象通过构造方法被实例化出来时，会实例化一个MessageQueue对象。MessageQueue是一个消息池，以链表的方式用于存放Message。

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

可以看到，每个Looper对象都有属于它的MessageQueue对象。

• loop()方法：

public static void loop(){
	final Looper me = myLooper();//一般情况为主线程的Looper
	If(me == null){
		throw new RuntimeException(“No Looper; Looper.prepare() wasn’t called on this thread.”);
	}
	final MessageQueue queue = me.Queue;// 主线程的Looper持有的MessageQueue自然也是在主线程中，里面的Message也是主线程的，关键点在于在Handler对象向子线程执行sendMessage方法，Message怎么从子线程跑到主线程了？
	……
	for(;;){
	// 轮询，取出MessageQueue里面的Message对象,next方法是MessageQueue的一个重要方法
		Message msg = queue.next();		// might block
		if( msg == null){
			return null;
		}
	……
	try{
		// 调用Handler的handleMessage()方法，返回一些计算结果的话，可以在主线程做更新UI的操作了
		msg.target.dispatchMessage(msg);
		dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
	} finally{
		……
	}
	}
}

MessageQueue类

Message next(){
	……
	for ( ; ; ){
	……
	synchronized(this)  {
		final long now = SystemClock.uptimeMillis();
		Message prevMsg = null;
		Message msg = mMessage;
		if(msg != null && msg.target == null){ // 还有其它消息要处理
			do{
				prevMsg = msg;
				msg = msg.next; // 链表操作，不断地读取下一个
			}while (msg != null && !msg.isAsynchronous());
		}
		if (msg != null){
			if(now < msg.when){
				nextPollTimeoutMillis = Math.min(msg.when - now, Integer.MAX_VALUE);
		}else{
			mBlocked = false;
			// 链表数据结构，将要处理的Message取出，标记为使用状态，也就是说处理的这个Message被移除出Message的链表了
			if(prevMsg != null){
				prevMsg.next = msg.next;
			}else{
				mMessage = msg.next;
			}
			msg.next = null;
			msg.markInUse();
			return msg;
	}
}
……
}
}
}

sendMessage方法

通过我们会在子线程调用Handler的sendMessage方法来发送消息，在handleMessage方法中处理逻辑，这个sendMessage方法最终会调用到sendMessageAtTime方法：
Handler：

    public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
        MessageQueue queue = mQueue;// Handler的MessageQueue对象mQueue就是Looper的MessageQueue对象，Looper的MessageQueue对象与线程绑定，也就是说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);
}

   private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
        msg.target = this;	// Looper的loop()方法中有 msg.target.dispatchMessage(msg) ，哪个Handler对象发送的消息，返回的结果就由哪个Handler对象来认领处理
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

enqueueMessage方法最终的实现在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();// Message标记为使用状态
            msg.when = when;
            Message p = mMessages;
            boolean needWake;
            if (p == null || when == 0 || when < p.when) {// p == null代表之前没有message
                // New head, wake up the event queue if blocked.
// 链表数据结构，将msg插到最前面
                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;
    }

Handler机制四个类之间的关系就是这样的了，正所谓篇幅不够代码凑，为了使篇幅不至于太少，同时也使意思达到，笔者尽量在代码中插入注释，使读者阅读源码时，通过提示更能理解源码，最重要的是理解源码。如有不正确的地方，欢迎指出，一起在交流探讨中学习成长。