1、什么是Android消息机制?什么是Handler?为什么要用Handler?
Android消息机制主要是指Handler的运行机制,Handler运行需要底层的MessageQueue和Looper支撑。其中MessageQueue采用的是单链表的数据结构来存储消息列表,Looper可以理解为消息循环。由于MessageQueue只是一个消息存储单元,不能去处理消息,而Looper就是用来处理消息的,Looper会以无限循环的形式去MessageQueue中查找是否有新消息,如果有则取出消息并处理,否则就一直阻塞等待。Looper中还有一个特殊的概念是ThreadLocal,ThreadLocal的作用是可以在每个线程中存储数据,在Handler创建的时候会采用当前线程的Looper来构造消息循环系统,Handler内部就是通过ThreadLocal来获取每个线程的Looper,线程默认是没有Looper的,在使用Handler之前必须先为主线程创建Looper。大家可能有疑惑了,我们在代码中使用Handler的时候,并没有为主线程去创建Looper的代码,为什么也可以正常使用呢?那是因为主线程中ActivityThread被创建时已经初始化主线程的Looper。
Handler主要用于异步消息的处理:当发出一个消息(Message)之后,首先进入一个消息队列(MessageQueue),发送消息的函数(sendMessage())即刻返回,而另外一个部分在消息队列中逐一将消息取出,然后对消息进行处理,也就是发送消息和接收消息不是同步的处理。 这种机制通常用来处理相对耗时比较长的操作,比如从服务端拉取一些数据、下载图片等。
在Android中规定访问UI只能在主线程中进行(因为Android的UI控件不是线程安全的,如果在多线程中并发访问可能会导致UI控件处于不可预期的状态),如果在子线程访问UI,程序会抛出异常。如在子线程中拉取服务端数据之后需要更新UI上控件展示内容,这个时候就需要切换到主线程去操作UI,此时就可以通过Handler将操作UI的工作切换到主线程去完成。因此,系统之所以提供Handler,主要原因就是为了解决在子线程中无法访问UI的矛盾。
2、Handler简单使用
2.1、创建Handler实例的两种方式
2.1.1 通过Handler.Callback
private Handler handler = new Handler(new Handler.Callback() {
@Override
public boolean handleMessage(Message msg) {
return false;
}
});
2.1.2 通过派生Handler的子类
private Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
}
};
2.2、Handler发送消息常用的两种方式
2.2.1 sendMessage
Message message = new Message();
message.obj = "JokerWan";
message.what = 666;
// 发送消息
handler.sendMessage(message);
// 发送延迟消息
handler.sendMessageDelayed(message,3000);
2.2.2 post
handler.post(new Runnable() {
@Override
public void run() {
// action
}
});
3、Handler运行机制原理图
4、Handler运行机制源码分析
温馨提示:为了方便大家阅读,我这里贴出的代码会对源码进行删减,只保留部分跟本文相关的关键代码,其他代码用...代替
4.1、主线程Looper的创建
首先我们看到ActivityThread
类中的main()
方法的代码
public static void main(String[] args) {
Trace.traceBegin(Trace.TRACE_TAG_ACTIVITY_MANAGER, "ActivityThreadMain");
...
Looper.prepareMainLooper();
...
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
...
Looper.loop();
throw new RuntimeException("Main thread loop unexpectedly exited");
}
其中有两个关键代码Looper.prepareMainLooper();
和Looper.loop();
,我们先看Looper.prepareMainLooper();
里面做了哪些事情
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
继续跟进其中调用的prepare(false);
方法
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));
}
这个方法中用到了sThreadLocal
变量,找到它的声明
static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
类型是ThreadLocal,泛型是Looper,ThreadLocal是一个线程内部的数据存储类,通过它可以在指定的线程存储数据,其他线程无法获取该线程数据。我们继续跟进下sThreadLocal.get()
方法,ThreadLocal#get()
public T get() {
Thread t = Thread.currentThread();
ThreadLocalMap map = getMap(t);
if (map != null) {
ThreadLocalMap.Entry e = map.getEntry(this);
if (e != null) {
@SuppressWarnings("unchecked")
T result = (T)e.value;
return result;
}
}
return setInitialValue();
}
调用getMap
方法并传入当前线程t
,返回保存当前线程中的数据ThreadLocal.ThreadLocalMap
的对象map
,ThreadLocalMap
类似于HashMap
,只不过ThreadLocalMap
仅仅是用来存储线程的ThreadLocal
数据,首先通过getMap()
获取当前线程的ThreadLocal
数据的map
,接着用ThreadLocal的对象作为key,取出当前线程的ThreadLocal
数据的map
中存储的result,由于前面sThreadLocal
变量声明的时候约定的泛型是Looper,所以这里返回result对象就是Looper对象,继续回到prepare()
方法,首先取出当前线程的Looper对象,校验下Looper对象的唯一性,然后new Looper(quitAllowed)
并保存在ThreadLocal当前线程中的数据中。
接着跟进Looper的构造方法
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
mThread = Thread.currentThread();
}
在Looper的构造函数中创建了一个MessageQueue的对象,并保存在Looper的一个全局变量mQueue
中,所以,每个Looper对象都绑定了一个MessageQueue对象。
4.2、Handler发送消息到MessageQueue
4.2.1 Handler构造器
public Handler() {
this(null, false);
}
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;
}
首先调用Looper.myLooper();
方法获取Looper对象,并保存在mLooper变量中,看一下Looper#myLooper()
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
若获取的Looper对象为null,则抛出异常Can't create handler inside thread xxThread that has not called Looper.prepare()
,因为上面我们已经分析过了,Looper对象的创建是在prepare()
方法中。
从ThreadLocal中获取当前线程(主线程)的Looper对象,接着将Looper中的MessageQueue保存到mQueue
中,并将callback赋值给mCallback,当我们通过匿名内部类创建Handler时callback为null。
4.2.2 Handler#sendMessage
public final boolean sendMessage(Message msg) {
return sendMessageDelayed(msg, 0);
}
public final boolean sendMessageDelayed(Message msg, long delayMillis) {
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
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);
}
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
return queue.enqueueMessage(msg, uptimeMillis);
}
可以看到不管是调用sendMessage
还是sendMessageDelayed
,还有后面会讲到的post(runnable)
,最终都会调用enqueueMessage
方法,方法里面首先将Handler对象赋值给msg.target
,后面会通过msg.target
获取Handler对象去处理消息(后面会讲到),然后调用了mQueue
的enqueueMessage(msg, uptimeMillis)
方法,
跟进MessageQueue#enqueueMessage()
boolean enqueueMessage(Message msg, long when) {
...
synchronized (this) {
...
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 {
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;
}
...
}
return true;
}
MessageQueue是一个消息队列,主要包含两个操作,插入和读取,插入就是上面这个方法enqueueMessage
,读取是next
方法,后面会讲到。尽管MessageQueue叫消息队列,但它内部实现并不是队列,而是用单链表的数据结构来维护消息列表,主要原因是单链表在插入和删除上效率比较高。从enqueueMessage
方法的实现来看,它的主要操作就是单链表的插入操作,将传进来的msg
插入到链表中,并将msg.next
指向上一个传进来的Message。
4.2.3 Handler#post
查看post方法源码
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
发现原来post
方法也是调用的sendMessageDelayed
方法去send Message,只是把我们传进来的Runnable对象通过调用getPostMessage
方法构造成一个Message
private static Message getPostMessage(Runnable r) {
Message m = Message.obtain();
m.callback = r;
return m;
}
通过Message.obtain()
获取一个Message,将Runnable对象赋值给m.callback
,并返回Message,到这里我们就知道了,原来post(Runnable r)方法只是把r
放进一个message中,并将message发送出去
4.3、Looper轮询MessageQueue并将消息发送给Handler处理
前面我们已经分析过,在ActivityThread类中的main()方法中会调用Looper.prepareMainLooper();
和Looper.loop();
,Looper.loop();
就是开启轮询的操作
public static void loop() {
final Looper me = myLooper();
if (me == null) {
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;
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;
}
...
try {
msg.target.dispatchMessage(msg);
...
} finally {
...
}
...
msg.recycleUnchecked();
}
}
首先获取到Looper对象和Looper对象里面的MessageQueue,然后构造一个死循环,在循环里面通过调用MessageQueue的next()
方法取出Message分发给Handler去处理消息,直到取出来的msg
为null,则跳出循环。msg.target
在enqueueMessage
方法中赋值为发送此Message的Handler对象,这里取出Handler对象并调用其dispatchMessage(msg)
去处理消息,而Handler的dispatchMessage(msg)
是在创建Handler时所使用的Looper中执行的,这样就成功的将代码逻辑切换到了指定的线程去执行。来看一下MessageQueue的next()
具体实现
Message next() {
...
for (;;) {
...
synchronized (this) {
// Try to retrieve the next message. Return if found.
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
if (msg != null && msg.target == null) {
// Stalled by a barrier. Find the next asynchronous message in the queue.
do {
prevMsg = msg;
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());
}
if (msg != null) {
if (now < msg.when) {
// Next message is not ready. Set a timeout to wake up when it is ready.
nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
} else {
// Got a message.
mBlocked = false;
if (prevMsg != null) {
prevMsg.next = msg.next;
} else {
mMessages = msg.next;
}
msg.next = null;
if (DEBUG) Log.v(TAG, "Returning message: " + msg);
msg.markInUse();
return msg;
}
} else {
// No more messages.
nextPollTimeoutMillis = -1;
}
...
}
}
可以看到next
是一个阻塞操作,开启一个死循环来取Message,当没有Message时,next
方法就会一直阻塞在那里,这也导致Looper.loop()
方法也一直阻塞。
4.4、Handler处理消息
Looper对象从MessageQueue中取到Message然后调用Handler的dispatchMessage(msg)
去处理消息
public void dispatchMessage(Message msg) {
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);
}
}
首先检查msg
的callback是否为null,不为null则调用handleCallback(msg)
来处理消息,还记得上面我们分析的post(runnable)
吗,这里从msg
取出的callback就是调用Handler的post方法传入的Runnable对象,看下handleCallback(msg)
代码实现
private static void handleCallback(Message message) {
message.callback.run();
}
实现很简单,就是取出Runnable对象并调用其中的run
方法。
dispatchMessage
方法接着检查mCallback是否为null,不为null就调用其handleMessage(msg)
方法,mCallback
类型为Callback接口,上面我们讲过Handler创建的两种方式,第一种方式就是在Handler的构造器中通过匿名内部类传入一个实现了Handler.Callback接口的对象,并在构造器赋值给mCallback
。
dispatchMessage
方法最后调用Handler的handleMessage(msg)
方法来处理消息,就是上面我们讲到的Handler创建的第二种方式:派生一个Handler的子类并重写其handleMessage
方法来处理消息。
5、主线程的消息循环
前面我们分析了ActivityThread
类中的main()
会创建Looper和MessageQueue,并将MessageQueue关联到Looper中,调用Looper的loop
方法来开启主线程的消息循环,那么主线程的消息是怎么发送的呢?ActivityThread
类内部定义了一个Handler的子类H
,ActivityThread
就是通过这个内部类H
来和消息队列进行交互并处理消息。
ActivityThread
通过 ApplicationThread
和 AMS 进行进程间通信, AMS以进程间通信的方式完成 ActivityThread
的请求后会回调 ApplicationThread
中的 Binder 方法,然后 ApplicationThread
会向 H
发送消息,H
收到消息后会将 ApplicationThread
中的逻辑切换到 ActivityThread
中去执行,即切换到主线程中取执行,这个过程就是主线程的消息循环模型。
6、总结
- Handler 的背后有 Looper、MessageQueue 支撑,Looper 负责消息分发, MessageQueue 负责消息管理;
- 在创建 Handler 之前一定需要先创建 Looper;
- Looper 有退出的功能,但是主线程的 Looper 不允许退出;
- 异步线程的 Looper 需要自己调用 Looper.myLooper().quit(); 退出;
- Runnable 被封装进了 Message,可以说是一个特殊的 Message;
- Handler.handleMessage() 所在的线程是 Looper.loop() 方法被调用的线程,也可
以说成 Looper 所在的线程,并不是创建 Handler 的线程; - 使用内部类的方式使用 Handler 可能会导致内存泄露,即便在 Activity.onDestroy
里移除延时消息,必须要写成静态内部类;