Android Handler相关面试题你能答对多少？子线程和主线程是如何切换的？

synchronized (sPoolSync) {

if (sPool != null) {

Message m = sPool;

sPool = m.next;

m.next = null;

m.flags = 0; // clear in-use flag

sPoolSize–;

return m;

}

}

return new Message();

}

2.当Activity有多个Handler的时候，Message消息是否会混乱？怎么样区分当前消息由哪个Handler处理？

不会混乱，哪个Handler发送的消息，到时候也是这个handler处理。在发送消息的时候，会绑定target,这个target就是Handler本身，当需要handler调用dispatchMessage(msg)处理消息的时候，这个Handler就是发送消息时绑定的handler。

无论用哪一种方法发送消息，最终都会调用enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis)来发送消息

private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {

msg.target = this;

if (mAsynchronous) {

msg.setAsynchronous(true);

}

return queue.enqueueMessage(msg, uptimeMillis);

}

这里的this，就是当前的handler。在来看需要Handler处理消息的时候，取的是哪一个handler,下面贴出主要源码。

public static void loop() {

…

for (;😉 {

Message msg = queue.next(); // might block

if (msg == null) {

// No message indicates that the message queue is quitting.

return;

}

// This must be in a local variable, in case a UI event sets the log

《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》

【docs.qq.com/doc/DSkNLaERkbnFoS0ZF】 完整内容开源分享

ger

…

if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {

Trace.traceBegin(traceTag, msg.target.getTraceName(msg));

}

final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;

final long dispatchEnd;

try {

msg.target.dispatchMessage(msg);

dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;

} finally {

if (traceTag != 0) {

Trace.traceEnd(traceTag);

}

}

…

msg.recycleUnchecked();

}

}

这是循环消息时的部分代码，处理消息代码是msg.target.dispatchMessage(msg);，这里的target就是当时发送消息的handler。

3.在子线程发送消息，却能够在主线程接收消息，主线程和子线程是怎么样切换的？

子线程用handler发送消息，发送的消息被送到与主线程相关联的MessageQueue，也是主线程相关联的Looper在循环消息,handler所关联的是主线程的Looper和MessageQueue,所以最后消息的处理逻辑也是在主线程。只有发送消息是在子线程，其它都是在主线程，Handler与哪个线程的Looper相关联，消息处理逻辑就在与之相关的线程中执行，相应的消息的走向也就在相关联的MessageQueue中。所以子线程切换到主线程是很自然的过程，并没有想象中的复杂。

4.能不能在子线程中创建Handler？

可以，但是在创建前先调用prepare()方法创建Looper。Handler创建的时候，会去检查是否有创建Looper,如果没有创建就会抛出异常。相关源码如下：

public Handler(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;

mCallback = callback;

mAsynchronous = async;

}

所以我们在子线程需要先调用prepare()方法创建Looper。这里还多提一点，在主线程创建就不需要自己创建Looper，因为在ActivityTread类里面，已经为我们创建好了，相关源码如下：

public static void main(String[] args) {

…

Looper.prepareMainLooper();// 为主线程创建looper

// Find the value for {@link #PROC_START_SEQ_IDENT} if provided on the command line.

// It will be in the format “seq=114”

long startSeq = 0;

if (args != null) {

for (int i = args.length - 1; i >= 0; --i) {

if (args[i] != null && args[i].startsWith(PROC_START_SEQ_IDENT)) {

startSeq = Long.parseLong(

args[i].substring(PROC_START_SEQ_IDENT.length()));

}

}

}

ActivityThread thread = new ActivityThread();

thread.attach(false, startSeq);

if (sMainThreadHandler == null) {

sMainThreadHandler = thread.getHandler();

}

if (false) {

Looper.myLooper().setMessageLogging(new

LogPrinter(Log.DEBUG, “ActivityThread”));

}

// End of event ActivityThreadMain.

Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);

Looper.loop();

throw new RuntimeException(“Main thread loop unexpectedly exited”);

}

Looper.prepareMainLooper();这句代码就是为主线程创建Looper。 所以在主线程中直接创建一个Handler，就直接可以循环消息，因为安卓的主线程已经为我们准备好了Looper。

5.一个线程可以有几个Handler?几个Looper?

一个线程可以有多个Handler，但是只有一个Looper。创建Handler之前，需要创建Looper，否则会报错。源码里面已经做了说明。

public Handler(Callback callback, boolean async) {

…

mLooper = Looper.myLooper();

if (mLooper == null) {//判断Looper是否被创建

throw new RuntimeException(

"Can’t create handler inside thread " + Thread.currentThread()

• " that has not called Looper.prepare()");

}

mQueue = mLooper.mQueue;

mCallback = callback;

mAsynchronous = async;

}

再来看Looper的创建，是在prepare()方法里。

// sThreadLocal.get() will return null unless you’ve called prepare().

static final ThreadLocal sThreadLocal = new ThreadLocal();

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

}

在创建之前去判断looper是否存在，存在就会抛出Only one Looper may be created per thread异常，这是在告诉我们一个线程只能有一个Looper。而TreadLocal的作用就是线程间隔离，确保一个线程对应一个Looper。还可以看看Looper构造方法的源码

private Looper(boolean quitAllowed) {

mQueue = new MessageQueue(quitAllowed);

mThread = Thread.currentThread();

}

MessageQueue的初始化是在Looper的构造方法里。不管一个线程有多少个Handler,相关联的都是同一个Looper和MessageQueue。

关于Handler，可以问的问题有很多，以上只是抽出一些我认为比较重要的问题。在寻找答案以后，我将Handler机制的整个过程在脑海中过了一遍，并且画了个草图。

Handler机制中重要类的相互关联图

---

Handler机制原理涉及几个重要的类：Handler、Message、MessageQueue、Looper。

就用子线程向主线程发送消息来说明整个过程。

首先在主线程创建一个Handler,在Handler类里面会创建Looper以及MessageQueue的对象，并且在Handler构造方法里面赋值