https://www.jianshu.com/p/b4d745c7ff7a
handler机制源码
1.handler机制的作用
在多线程的场景中,将子线程中需要更新UI的操作信息传递到UI主线程。多个线程并发更新UI的同时 保证线程安全。
Message
线程间通信的数据单元(handler接受和处理的消息对象),存储需要操作的通信信息。
Message Queue
一种数据结构(先进先出)用来存储handler发过来的Message
Handler
主线程与子线程之间通信的媒介,线程消息的主要处理者.1、添加Message到MessageQueue中 2、处理Looper分派过来的Message.
Looper
MessageQueue与Handler之间的媒介，循环的取出MessageQueue里面的Message并分配给相应的Handler去处理。每个线程只能拥有一个Looper,但是一个Looper可以绑定多个线程的Handler
即：多个线程可以向同一个Looper管理的MessageQueue中发送Message。
handler发送消息的方式有2中
handler.sendMessage() 和 handler.post()
handler是怎样绑定线程的
一个handler只能绑定一个Looper对象，一个线程只能绑定一个Looper，但是一个Looper可以有多个handler，一个线程也可以有多个handler。
handler是通过绑定looper来绑定线程。
是通过Handler的构造方法来绑定Looper的
Looper的源码
prepare();
里面会调用prepare(true)方法
public static void prepare() {
prepare(true);
}
//去创建loopre对象
private static void prepare(boolean quitAllowed) {
//判断当前线程的loopre对象是否已经创建过 如果已经创建过就会抛出异常
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
//真正的去创建looper对象,并放进sThreadLocal中
sThreadLocal.set(new Looper(quitAllowed));
}
//Looper的构造方法 创建Looper 和 MessageQueue的对象 和当前线程的引用
private Looper(boolean quitAllowed) {
mQueue = new MessageQueue(quitAllowed);
//获取当前线程的引用
mThread = Thread.currentThread();
}
//主线程创建Looper的方法并且从sThreadLocal获取这个对象
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
//从ThreadLocal中获取当前线程的looper对象
public static @Nullable Looper myLooper() {
return sThreadLocal.get();
}
//获取主线程的looper对象
public static Looper getMainLooper() {
synchronized (Looper.class) {
return sMainLooper;
}
}
//获取当前线程的MessageQueue对象
public static @NonNull MessageQueue myQueue() {
return myLooper().mQueue;
}
//当前线程的引用是否是Looper所在的线程
public boolean isCurrentThread() {
return Thread.currentThread() == mThread;
}
//从开机到现在的毫秒数(手机睡眠的时间不包括在内)
final long now = SystemClock.uptimeMillis();
//当前消息的前一个消息
Message prevMsg = null;
//当前的消息
Message msg = mMessages;
//如果当前的消息不为空并且处理该消息的handler也不为空
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());
}
Message的回收和复用：https://www.cnblogs.com/leipDao/p/7850473.html
//使用的是单链表的数据结构sPool指向链表的头部
private static Message sPool;
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()总结
好了，到此主要逻辑就分析完了，obtain()主要逻辑就是先判断缓存池中是否存在空闲message，
如果存在则返回头部message,并且指针指向下一个空闲message,
然后头部的message与之后链表 断开连接。如果不存在空闲message则直接new一个直接返回
上面的逻辑都是从缓存池中获取的操作，那什么时候向缓存池中存放呢？
public void recycle() {
if (isInUse()) {
if (gCheckRecycle) {
throw new IllegalStateException("This message cannot be recycled because it "
+ "is still in use.");
}
return;
}
recycleUnchecked();
}
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++;
}
}
}
recycle()最主要就是将当前message放入缓存池链表头部。
MessageQueue取出消息的原理： Message next() {}
nextPollTimeoutMillis：阻塞的时间 -1表示会一直阻塞，0表示不阻塞 其他时间为具体阻塞的时间
Handler是怎么发送消息到MessageQueue里面的，又是怎样处理消息的？
1.通过
private Handler handler=new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
}
};
public Handler() {
//第一个参数==null
this(null, false);
}
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 " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
mQueue = mLooper.mQueue;
//此时这个值是空
mCallback = callback;
mAsynchronous = async;
}
public void handleMessage(Message msg) {
}
public interface Callback {
/**
* @param msg A {@link android.os.Message Message} object
* @return True if no further handling is desired
*/
public boolean handleMessage(Message msg);
}
可以看到在Handler创建的时候会绑定一个当前线程的Looper
在处理消息的时候：
public void dispatchMessage(Message msg) {
//如果msg.callback != null 标识是通过 handler.post(new Runnable() {}的方式发送消息的
if (msg.callback != null) {
handleCallback(msg);
} else {
否则就会回调我们的handleMessage方法。
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
否则就会回调我们的handleMessage方法。
handleMessage(msg);
}
}
handleCallback(msg); 就会执行下面的方法 进而回调我们的Run方法
private static void handleCallback(Message message) {
message.callback.run();
}
发送消息：
sendEmptyMessage(int what)
--->sendEmptyMessageDelayed(int what, long delayMillis)
--->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);
}
//最终会跑到MessageQueue中去处理
return queue.enqueueMessage(msg, uptimeMillis);
}