Handler在Android提供用于更新UI的一套机制,也是消息处理机制
首先讲里面四个对象
-Message:消息对象,是在线程之间传递的消息,它可以在内部携带少量信息.可以传递bundle数据
-MessageQueue:存储消息对象的队列,每个线程只有一个,阻塞队列.
-Looper:负责循环读取MessageQueue中的消息,读到消息之把消息交给Handler去处理.是每个线程中MessageQueue的管家,调用Looper.loop()方法后,就会进入到一个无限循环中,会从头开始取消息并传递到Handler的handlerMessage()方法中,每个线程只有一个looper对象.
-Handler:发送消息与处理消息.在其子线程或当前线程发送Message,在UI线程处理消息对象,发送的消息经过处理后最终在handlerMessage方法中处理.
Message类
public final class Message implements Parcelable {
//用于区别消息的类型
public int what;
//携带数据，空消息所携带的数据
public int arg1;
public int arg2;
//携带数据（进程间通信时只能携带系统定义的parcelable对象，自定义的不行）
public Object obj;
//Messenger进行进程间通讯时，用于实现双向通讯
public Messenger replyTo;
//携带数据，可存放多条
Bundle data;
//消息所携带的代码语句数据
Runnable callback;
//消息的处理目标对象，用于处理消息
Handler target;
//用于标记该Message是否在被使用
int flags;
//存放时间，用于在MessageQueue中实现排序
long when;
//用于实现单链表，以链表实现Message池
Message next;
//链表头指针
private static Message sPool;
private static int sPoolSize = 0;//池的当前大小
private static final int MAX_POOL_SIZE = 50;//池的最大容量
...
}
public static Message obtain() {
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();
}
Message使用了一个数据池sPool来对Message对象进行回收和再利用,所以建议用obtain方法来获取Message,避免多次分配对象,sPool的上限是MAX_POOL_SIZE = 50.
当开始obtain方法时首先开启了一个对象锁synchronized,如果当sPool不为空的时候,也就是有数据时,会取出表头的Message然后池内数据减1.
public void recycle() {
if (isInUse()) {
if (gCheckRecycle) {
throw new IllegalStateException("This message cannot be recycled because it "
+ "is still in use.");
}
return;
}
recycleUnchecked();
}
回收时会先检查一下当前的Message是否正在使用,然后调用recycleUnchecked方法进行回收,当使用完一个Message时,要将不使用的Message回收.
void recycleUnchecked() {
// Mark the message as in use while it remains in the recycled object pool.
// Clear out all other details.
flags = FLAG_IN_USE;
what = 0;
arg1 = 0;
arg2 = 0;
obj = null;
replyTo = null;
sendingUid = -1;
when = 0;
target = null;
callback = null;
data = null;
synchronized (sPoolSync) {
if (sPoolSize < MAX_POOL_SIZE) {
next = sPool;
sPool = this;
sPoolSize++;
}
}
}
recycleUnchecked方法回收之前先重置Message的状态,将状态都清空,将Message放回对象池时会首先判断对象池的容量是否已经满了,只有未满的时候才会回收进对象池,否则将会丢弃等待GC的回收
MessageQueue类
是一个队列类型的数据结构,总体上就是先进先出的访问顺序,实现方式和Message对象池一样,也是由Message连接而成的单链表.Message有个long whent属性,就是存入MessageQueue的时间.而MessageQueue会按照when的大小将Message列表进行排序.
MessageQueue(boolean quitAllowed) {
mQuitAllowed = quitAllowed;
mPtr = nativeInit();
}
构造方法设置了一下是否允许退出队列的值并执行了一条native函数进行初始化.mPtr是指针地址
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) {
//若是该队列已经退出，则直接回收消息，只有在quit方法中才设置该属性为true
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;
//p指向队列（单链表）的头部
Message p = mMessages;//这里的队列也是由Message构成的单链表
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 {
needWake = mBlocked && p.target == null && msg.isAsynchronous();
//按照时间顺序（从小到大）将Message插在对应的位置
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;
}
//这里在插入方法中可以看出，只要插入的Message不是异步的，那么
//needWake的值就会是mBlocked的值，而mBlocked的值会在出队方
//法next中，当线程阻塞的时候设为True。而这里当有非异步的Message入队时，
//就会调用nativeWake方法将线程唤醒来处理消息
if (needWake) {
nativeWake(mPtr);
}
}
return true;
}
enqueueMessage会按照时间从小到大的顺序将消息插入在相应的位置.因为MessageQueue中的队列是由Message实现的,也就是Message和它的属性next实现的单链表.而单链表只能按照从头至尾的顺序访问,因为入队插在表尾,而出队是从表头取出的.也会判断是否需要唤醒线程.
Message next() {
//ptr是native层对象指针，为0时表示MessageQueue已经结束
final long ptr = mPtr;
if (ptr == 0) {
return null;
}
int pendingIdleHandlerCount = -1; // -1 only during first iteration
int nextPollTimeoutMillis = 0;
for (;;) {
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
nativePollOnce(ptr, nextPollTimeoutMillis);
}
...
}
next方法中调用了一个死的for循环,以及一个nativePollOnce的native方法(陷入阻塞,等待被唤醒).
在队列为空或消息暂未达到处理时间的时候,线程会阻塞,这里阻塞是通过native层的epoll方式进行的阻塞.enqueuMessage
Message next() {
...
int nextPollTimeoutMillis = 0;
for (;;) {
...
//根据我们上面的分析，nextPollTimeMillis为0则不阻塞，也就是第一次循环不阻塞
nativePollOnce(ptr, nextPollTimeoutMillis);
synchronized (this) {
final long now = SystemClock.uptimeMillis();
Message prevMsg = null;
Message msg = mMessages;
//这里判断msg不为空但是target为空，而我们enqueueMessage的时候特意设置了target的
//所以这里的msg不是我们设置而是系统在初始化的时候设置的屏障，这里不再详解
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());
}
//这里是正常情况下的msg
if (msg != null) {
//未达到处理时间的，将会计算需要等待的时间，不超过整形的最大值
if (now < msg.when) {
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 {
nextPollTimeoutMillis = -1;
}
//上面分别对消息队列进行判断然后修改nextPollTimeoutMillis，而之前的分析可以看出这个值就是线程
//需要阻塞的时长，有未达到处理时间的消息则阻塞对应时间，没有消息则一直阻塞直到被唤醒
...
}
...
}
}
Lopper类
looper有两个方法可以得到Looper对象,prepareMainLooper(主线程调用)和prepare方法
prepareMainLooper在主线程中调用.
prepare会先判断是否已经创建过,创建过会抛出异常,所以一个线程只能对应一个looper,如果没创建过,就会创建一个looper放到ThreadLocal中,而ThreadLoacl是按照线程信息存储数据的,获取时也是根据当前线程获取对应数据.Looper会创建一个消息队列MessageQueue,每个Looper会对应一个消息队列.调用 loop方法就会执行死循环一直从消息队列中取消息.
死循环未造成卡顿的原因是MessageQueue的next方法中,若是队列中没有Message时,则会阻塞在这里.因此不会造成系统的卡顿.
调用prepare再调用loop()来开启循环.阻塞式地从消息队列中取消息.
Handler类
构造方法中的一些属性,都是从Looper中的ThreadLocal中获取的.
enqueueMessage时将msg.target赋值为this.将来在looper.loop中调用target.handleMessage
若是没有指定looper,则使用实例化Handler时所在线程的Looper,若是指定,则使用指定的Looper.
如果构造方法传入callback则执行callback的handleMessage处理,否则使用Handler本身的handlerMessage处理消息.