Handler消息机制
Message
创建Message的方法:
- Message msg=new Message()
- Message msg=Message.obtain()
- handler.obtainMessage()
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();
}
这里的obtain方法 , 为一个链表的插入操作
MessageQueue
存放Message的数据结构 , 为单向链表 .
默认的msg的when都是0 ,后加的放在最前面.
如果when!=0 , 那么when值小的放在前面
Handler
消息处理类 , 用于UI的处理
Looper
轮询器,Linux底层的管道通信
Handler消息处理过程
Handler的创建
Handler handler=new Handler(){
handlerMessage(Message msg){
//更新UI
}
}
准备sThreadLocal
- 在ActivityThread中初始化Looper
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()方法 , 能发现我们要找到的东西 , 填充线程容器, 在Handler的默认构造方法中取值.
线程容器可以收集线程并通过set来设置线程的tag ,同时通过get(tag)来获取到想要的线程
private static void prepare(boolean quitAllowed) {
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
//创建一个Looper , 将其加入到线程容器中
sThreadLocal.set(new Looper(quitAllowed));
}
Handler的构造函数
public Handler(Callback callback, boolean async) {
......
//轮训器的初始化, 在主线程中
mLooper = Looper.myLooper();
if (mLooper == null) {
throw new RuntimeException(
"Can't create handler inside thread that has not called Looper.prepare()");
}
//创建成功 , 从轮训器中获取消息队列
mQueue = mLooper.mQueue;
//空构造函数 , 将callback置空
mCallback = callback;
mAsynchronous = async;
}
- Looper.myLooper();
public static @Nullable Looper myLooper() {
//从线程容器中获取线程 , 上文中提到线程变量的加入, 在这里取值,得到轮训器对象
return sThreadLocal.get();
}
- mQueue = mLooper.mQueue; //获取轮询器的消息队列
Handler发送消息
- handler.sendMessage(); //发送消息
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0);
}
- 跟进sendMessageDelayed方法:
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
}
在这个方法体中 , 我们调动的sendMessage方法不传入时间 , 在这里默认置为0 .然后跟进她的返回值的方法:sendMessageAtTime
- sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis)
public boolean sendMessageAtTime(Message msg, long uptimeMillis) {
这个mQueue为Handler中构造函数赋值, 为轮询器的消息队列
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);
}
- enqueueMessage方法
private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
// 把自己的handler和message做了绑定 , 这个方法在Handler类中 , 所以这里的this就是Handler的实例
msg.target = this;
if (mAsynchronous) {
msg.setAsynchronous(true);
}
//将消息按时间顺序入队列 , queue为上文提到的队列
return queue.enqueueMessage(msg, uptimeMillis);
}
- enqueueMessage:
按照时间顺序进入队列 , 如果是队首 , 会进行唤醒操作 .
排序: 按消息的时间排序 , 如果时间一样, 后加的排在前面
Looper轮询器取消息
在应用程序启动前 ,
ActivityThread的main方法已经执行并开始准备接收消息
1, looper.loop方法
- 在循环中 ,获取到消息就执行分发消息的操作
msg.target.dispatchMessage(msg)
调用Handler的dispatchMessage分发消息.
public void dispatchMessage(Message msg) {
//如果没有callback说明调用了runOnUIThread方法
if (msg.callback != null) {
handleCallback(msg);
} else {
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
//在主线程中 ,调用Handler的handlerMessage处理消息 , 这里为类内部的接口的接口方法
handleMessage(msg);
}
}
- 主线程中 , 调用Handler的handlerMessage来处理消息
- msg.recycler();
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++;
}
}
}
