今天总结一下这个Handler 的一些常常被问的问题,有借鉴,也有总结。如果后面还有新的问题,会添加上去。
1. Handler 机制中涉及到那些类,各自的功能是什么
主要的类就4个 Handler Lopper MessageQueue Message 主要是这4个
-
Handler 的作用就是将Message对象发送到MessageQueue中,同时将自己的引用赋值给Message#target
-
Looper 的作用是将Message 对象从MessageQueue中取出来,并将其交给Handler#dispatchMessage(Message) 这里需要注意的是不是调用**Handler#handleMessage(Message)**方法。
-
MessageQueue的作用就是负责插入和取出Message
- 这里的ThreadLocal 不在此记录,因为这是JDK 中本身自带的
2. 有哪些发送消息的方法
sendMessage(Message msg)
sendMessageDelayed(Message msg,long uptimeMillis)
sendMessageAtTime(Message msg,long when)
sendEmptyMessage(int what)
sendEmptyMessageDelayed(int what,long uptimeMillis)
sendEmptyMessageAtTime(int what,long when)
Post(Runnable r)
postDelayed(Runnable r,long uptomeMillis)
方法有好多重,其实归根结底就 sendMessageAtTime(Message msg , long when) 这一个
3. MessageQueue 中的 Message 是有序的吗?排序的依据是什么
- 是有序的。Queue都是有序的 Set 才是无序的
- 这里的排序依据是Message#when这个字段,表示一个相对时间,改值是由 MessageQueue#enqueueMessage(Message msg , Long when) 方法设置的。
final boolean enqueueMessage(Message msg, long when) {
// ....
boolean needWake;
synchronized (this) {
if (mQuiting) {
RuntimeException e = new RuntimeException(
msg.target + " sending message to a Handler on a dead thread");
Log.w("MessageQueue", e.getMessage(), e);
return false;
}
msg.when = when;
Message p = mMessages;
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 {
// 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;
}
}
if (needWake) {
nativeWake(mPtr);
}
return true;
}
- 当两个 Message#when 一致时插入序按先后顺序
4. Message#when 是指的是什么
Message#when 是一个时间,用于表示 Message 期望被分发的时间,该值是SystemClock#uptimeMillis() 和 delayedMillis 之和
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
SystemClock#uptimeMillis() 是一个表示当前时间的一个相对时间,它代表的是 自系统启动开始从0开始的到调用该方法时相差的毫秒数 。
5. Message#when 为什么不用System.currentTimeMillis() 来表示
/**
* Returns the current system time in milliseconds since January 1, 1970
* 00:00:00 UTC. This method shouldn't be used for measuring timeouts or
* other elapsed time measurements, as changing the system time can affect
* the results.
*
* @return the local system time in milliseconds.
*/
public static native long currentTimeMillis();
System.currentTimeMillis() 表示的是从1970-01-01 00:00:00 到当前时间的毫秒数值,我们可以通过修改系统时间达到修改改值的目的,所以改值是不可靠的值。 可能会导致 延迟消息失效
同时 Message#when 只是用 时间差 来表示先后关系,所以只需要一个相对时间就可以达到目的,它可以是从系统启动开始计时的,也可以是从APP启动开始计时的,甚至可以定期重置的,(所有消息都减去同一个值,不过这样就复杂了没有必要)。
6. 子线程中可以创建Handler 对象吗?
- 先调用Looper.prepare() 在当前进程中初始化一个Looper
Looper.prepare();
Handler handler = new Handler();
// ....
// 这一步可别少了
Looper.loop();
Looper looper = .....;
Handler handler = new Handler(looper);
7. Handler 是如何与 Looper 进行关联的
- 通过构造方法传参
- 直接调用无参构造方法 其里面有一个自动绑定的过程 mLooper = Looper.myLooper();
public Handler(Callback callback, boolean async) {
if (FIND_POTENTIAL_LEAKS) {
final Class<? extends Handler> klass = getClass();
if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
(klass.getModifiers() & Modifier.STATIC) == 0) {
Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
klass.getCanonicalName());
}
}
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;
}
8. Looper 是如何与Thread 关联的
这里是通过 ThreadLocal 进行关联的,这个可以从 Looper#prepare() 方法看出来
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
//....
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 中有一个 ThreadLocal 类型的 sThreadLocal静态字段,Looper通过它的 get 和 set 方法来赋值和取值。
public static Looper myLooper() {
return sThreadLocal.get();
}
...
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));
}
由于 ThreadLocal是与线程绑定的,所以我们只要把 Looper 与 ThreadLocal 绑定了,那 Looper 和 Thread 也就关联上了
9. Handler 有哪些构造方法
Handler 可以传的参数仅有两种 Looper、Handler#Callback
那么就可以推算出一共有多少种构造方法了 一共四种
- 无参
- 单Looper
- 单Callback
-
Looper、Callback
public Handler() {
this(null, false);
}
public Handler(Callback callback) {
this(callback, false);
}
public Handler(Looper looper) {
this(looper, null, false);
}
public Handler(Looper looper, Callback callback) {
this(looper, callback, false);
}
还有一个隐藏的 boolean 的async ,不过这个不是开放的API
10. 在子线程中如何获取当前线程的 Looper
Looper.myLooper()
内部原理就是同过上面提到的 sThreadLocal#get() 来获取 Looper
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
11. 如果在任意线程获取主线程的 Looper
Looper.getMainLooper()
12.如何判断当前线程是不是主线程
Looper.myLooper() == Looper.getMainLooper()
Looper.getMainLooper().getThread() == Thread.currentThread()
Looper.getMainLooper().isCurrentThread()
13.Looper.loop() 会退出吗?
不会自动退出,但是我们可以通过 Looper#quit() 或者 Looper#quitSafely() 让它退出。
两个方法都是调用了 MessageQueue#quit(boolean) 方法,当 MessageQueue#next() 方法发现已经调用过 MessageQueue#quit(boolean) 时会 return null 结束当前调用,否则的话即使 MessageQueue 已经是空的了也会阻塞等待。
14.MessageQueue#next 在没有消息的时候会阻塞,如何恢复?
当其他线程调用 MessageQueue#enqueueMessage 时会唤醒 MessageQueue,这个方法会被 Handler#sendMessage、Handler#post 等一系列发送消息的方法调用。
boolean enqueueMessage(Message msg, long when) {
// ...
synchronized (this) {
// ...
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 {
// ...
}
if (needWake) {
nativeWake(mPtr); // 唤醒
}
}
return true;
}
15. Looper.loop() 方法是一个死循环为什么不会阻塞APP
因为所有让我们会觉得的卡住的都被放到了MessageQueue 里面,然后通过Looper 取出并交给 Handler 进行执行了。