从源码角度分析 Handler Looper MessageQueue

发表于 | 分类于 ， |

前言

首先我们要知道，创建Handler之前，要先创建与之配套的Looper。
在主线程中，系统已经初始化了一个 Looper 对象，因此程序直接创建 Handler 对象即可，然后就可以通过 Handler 来发送、处理消息了。
在子线程中，必须自己创建一个 Looper 对象，并启动它。
创建 Looper 对象调用它的 prepare 方法即可(prepare 方法保证每个线程最多只有一个 Looper 对象)，然后调用 Looper 的静态 loop 方法来启动它。loop 方法使用一个死循环不断地从MessageQueue 中取消息，并将取出的消息分发给该消息对应的 Handler 处理。至于它们具体做了哪些事，我们会在后面详细讲述。

Looper的创建

我们先看一下Looper的构造函数

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

首先我们注意到该构造方法是被private修饰的，也就是说我们无法通过new的方式来创建Looper。其次，我们可以从Looper的构造方法中看出，在创建Looper的时候，创建了与之配套的MessageQueue，然后获取了创建当前Looper线程的引用。
而要想创建Looper，只需调用Looper.prepare();。该方法保证了一个线程只能创建一个与之相关联的Looper，并且将创建出的Looper与当前线程绑定起来。

1
2
3
4
5
6
7
8
9
10
public static void prepare() {
    prepare(true);
}

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

Handler的创建

Looper对象成功创建之后，我们再来看看Handler。当我们调用Handler的无参构造函数创建Handler时，它内部调用了另一个重载的构造方法this(null, false)。

1
2
3
4
5
6
7
8
9
10
11
12
public Handler(Callback callback, boolean async) {
    ...//something we just ignore

    mLooper = Looper.myLooper();
    if (mLooper == null) {
        throw new RuntimeException(
            "Can't create handler inside thread that has not called Looper.prepare()");
    }
    mQueue = mLooper.mQueue;
    mCallback = callback;
    mAsynchronous = async;
}

从构造方法中，我们可以看出，handler获取了与当前线程相关联的Looper及MessageQueue的引用。

Handler 发送消息

创建完Handler之后，我们先从handler.sendMessage()说起：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
public class MainActivity extends Activity{
	protected void onCreate(Bundle onSavedInstanceState){
		super.onCreate(onSavedInstanceState);
		setContentView(R.layout.main);
    
		MyRunnable mRunnable = new MyRunnable();
		Thread mThread = new Thread(mRunnable);
		mThread.start();
	}
  
	public static Handler = new Handler(){
		@Override
		public void handleMessage(Message msg){
			//do some magic
		}
	};
  
	static class MyRunnable implements Runnable{
		@Override
		public void run(){
			Message msg = Message.obtain();
			//do some magic
			handler.sendMessage(msg);
		}
	}
}

而不管我们调用sendEmptyMessage()或者是sendMessage()，最终都会走到这里：

1
2
3
4
5
6
7
8
9
10
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);
}

关键是最后return时，调用了enqueueMessage()，我们一起看一下该方法的具体实现：

1
2
3
4
5
6
7
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
    msg.target = this;
    if (mAsynchronous) {
        msg.setAsynchronous(true);
    }
    return queue.enqueueMessage(msg, uptimeMillis);
}

从enqueueMessage的方法实现可以看出，要发送的消息获取到了当前Handler的引用，也就是msg.target 。然后这条信息被加入到了与当前线程相关联的MessageQueue中。到此，发送消息的逻辑已经结束。
那么Handler处理消息的方法又是在什么时候回调的呢？要弄明白这一点，我们要对Looper.loop()进行分析。

Looper.loop();

前面我们也已经提过，要创建一个Handler其实是需要三个步骤的：

  1. 调用Looper.prepare();
  2. 创建Handler
  3. 调用Looper.loop();
    ​
    前面两步我们已经讲解过了，那你肯定会好奇，loop()中到底做了什么呢？我们一起来看一下。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public static void loop() {
	//获取与当前线程相关联的Looper对象
    final Looper me = myLooper();
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
	//获取与Looper对象相匹配的MessageQueue
    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();

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

        ...//something we just ignore

        msg.target.dispatchMessage(msg);

        ...//something we just ignore

        // Mark the message as in use while it remains in the recycled object pool. Clear out all other details.
        msg.recycleUnchecked();
    }
}

从源码可以看出，loop()其实调用了一个死循环，不断的从与Looper配套的MessageQueue中取消息，然后调用msg.target.dispatchMessage(msg);进行消息的分发。
前面Handler发送消息的时候，我们已经分析过，每个要发送的Message都获取到了发送它的Handler的引用，也就是msg.target。因此这里msg.target.dispatchMessage(msg);其实也就是调用了handler的dispatchMessage进行消息的分发。

Handler的handleMessage()何时被回调？

我们一起来看一下handler的dispatchMessage():

1
2
3
4
5
6
7
8
9
10
11
12
public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}

很明显，就是在这里，Handler的handleMessage被回调了。
综上，我们可以说，是在Looper.loop()中，当循环不断的从MessageQueue中获取消息时，间接调用了Handler的handleMessage()方法。