Android Handler机制

• 《Android Handler机制》
• 《Android Handler分析（一） Handler和Message详解》
• 《Android Handler分析 (二) MessageQueue详解》
• 《Android Handler分析 (三) Looper详解和Handler其他知识》
• 《Android 中的 HandlerThread 类详解》

作为一个Android程序员，我想大家都知道在做一些比较耗时的操作的时候都不会放在主线程，比如网络请求、数据库操作等(尤其是网络请求，在Android4.0之后强制不能放在主线程中执行，否则抛出android.os.NetworkOnMainThreadException异常)，而更新UI的操作的都是由UI线程处理。那么有这样一个需求，我在一个新的线程中获取到数据，然后设置到界面上，这就涉及到了两个线程，用于更新界面的UI线程不知道什么时候数据获取完成可以更新界面了，那怎么办呢？Google就给我们提供了一个解决方案，也就是我们今天主要说明的内容——Android中的Handler消息机制。

首先来一个简单使用：

private static final int HANDLER_TEST_WHAT = 0x01; // 定义测试what

// 创建Handler对象，并重写handleMessage()方法处理消息
private Handler handler = new Handler(){
	@Override
	public void handleMessage(Message msg) {
	    int what = msg.what; // 获取消息的what
	    // 通过what对消息进行判断，不同消息不同的处理
	    if(what == HANDLER_TEST_WHAT){
		// 处理消息
	    }
	}
};

// 创建一个子线程发送消息
new Thread(){
    @Override
    public void run() {
	Message message = Message.obtain(); // 创建一个消息对象，使用obtain()重用回收的消息对象
	message.what = HANDLER_TEST_WHAT;   // 设置Message的 what
	handler.sendMessage(message);       // 发送一个消息
    }
}.start();

上面就是一个简单的例子，在子线程发送一个消息，然后在主线程就可以对消息进行处理，当然包括更新UI或者其他操作。

下面我们就从源码的角度查看与分析一下Handler消息机制，他是怎样将一个子线程的数据传递到主线程中的。

介绍Handler机制之前，首先了解几个概念：

• **Message：**消息，理解为线程间通讯的数据单元。例如后台线程在处理数据完毕后需要更新UI，则可发送一条包含更新信息的Message给UI线程。
• **MessageQueue：**消息队列，用来存放通过Handler发布的消息并按时间进行排序，按照先进先出执行。
• **Handler：**Handler是Message的主要处理者，负责将Message添加到消息队列以及对消息队列中的Message进行处理。
• **Looper：**轮询器，扮演MessageQueue和Handler之间桥梁的角色，循环取出MessageQueue里面的Message，并交付给相应的Handler进行处理。

消息机制分析

从上面的示例中，我们先创建了一个Handler对象并且重写了 handleMessage() 方法用来处理接收到的消息，而消息的发送是通过 Handler 的sendMessage() 方法。也可以说，Handler机制是由 sendMessage() 方法开始，到 handleMessage() 方法结束，现在我们就来一步一步看看数据是怎样传递的，线程又是怎样切换的。

首先看看创建 Handler

最终调用的是 带两个参数 的构造方法，如下：

	public Handler(@Nullable Callback callback, boolean async) {
        
        mLooper = Looper.myLooper();
        if (mLooper == null) {
            throw new RuntimeException(
                "Can't create handler inside thread " + Thread.currentThread()
                        + " that has not called Looper.prepare()");
        }
        mQueue = mLooper.mQueue;
    }

说明：

1. Looper.myLooper()：获取当前线程的 Looper 对象，也就是线程需要是一个 Looper 线程，主线程就是一个 Looper 线程，主线程为什么是一个Looper线程以及怎样将一个线程变为 Looper 线程，在《Android Handler分析 (三) Looper详解和Handler其他知识》中有说到。

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

2. mLooper.mQueue：就是一个 MessageQueue 对象，他是在 Looper 构造方法中初始化的

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

我们创建了 Handler 对象之后，然后通过 Handler 的 sendMessage() 方法发送一个 Message，接下来看看 sendMessage() 方法做了写什么事

Handler#sendMessage() 方法

	public final boolean sendMessage(@NonNull Message msg) {
        return sendMessageDelayed(msg, 0);
    }

	public final boolean sendMessageDelayed(@NonNull Message msg, long delayMillis) {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

	public boolean sendMessageAtTime(@NonNull 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);
    }

	private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg, long uptimeMillis) {
		// 注意这行代码，将 Message 的 target 变量赋值成 this，也就是当前 Handler 对象
        msg.target = this;
        msg.workSourceUid = ThreadLocalWorkSource.getUid();

        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

说明：

1. sendMessage() 方法调用了一些 Message 类自身的发送方法，主要是处理消息发送时间（立马发送还是延迟发送等）
2. 最终调用 enqueueMessage() 方法，在这个方法中又调用了 queue.enqueueMessage(msg, uptimeMillis) ，queue 就是 MessageQueue，所以查看一下 MessageQueue 中的 enqueueMessage() 方法
3. 重点注意enqueueMessage() 方法中的 msg.target = this 代码，将 Message 的 target 变量赋值成 this，也就是当前 Handler对象

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) {
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
        } else {
            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;
}

这个方法所做的事情就是将 Message 对象根据发送时间添加到队列中，方法的具体分析在 《Android Handler分析 (二) MessageQueue详解》中。

Message 消息对象添加到 MessageQueue 中之后，在哪里取出来，并且传递到 handleMessage() 方法呢？

这里我们就有必要先说一下 Looper 线程了，一个类变为Looper线程并且能处理消息，主要有两步：

1. 调用 Looper.prepare() 方法
2. 调用 Looper.loop() 方法开始轮询

至于这两个方法具内容是什么我们这里就不说了，在《Android Handler分析 (三) Looper详解和Handler其他知识》中有分析，只需要知道 loop() 方法最重要的作用就是不断的循环调用 MessageQueue 的 next() 方法去获取 Message ，然后进行处理，而 MessageQueue 的 next() 方法的消息分析在 《Android Handler分析 (二) MessageQueue详解》中，它的主要作用就是按照顺序从队列里面取出 Message。

所以我们直接看 MessageQueue.next() 取到消息之后 Looper.loop() 方法是怎样处理的，核心代码如下：

public static void loop() {
	final Looper me = myLooper();
	final MessageQueue queue = me.mQueue;
	Message msg = queue.next();
	try {
        msg.target.dispatchMessage(msg);
    } catch (Exception exception) {
    } finally {
    }
}

说明：

通过获取的 Message 对象的变量 target, 调用它的 dispatchMessage() 方法，并且将 msg 对象传递给 dispatchMessage() 方法。在上面，我们已经知道了 target 变量表示的就是 Handler，所以这里调用的就是 Handler 的 dispatchMessage() 方法了。

Handler#dispatchMessage() 方法

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

在 dispatchMessage() 方法中调用了 handleMessage(msg) 方法并传递 Message，这个方法我们在创建 Handler 时重写了。所以就走到了我们自己处理消息的部分。因为我们的这个Handler是在主线程创建的并且绑定的也是主线程的Looper，所以这个方法就在主线程当中执行了。