Handler源码
Posted cao_null
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Handler源码相关的知识，希望对你有一定的参考价值。
Handler
public Handler() {
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());
}
}
//调用了Looper
mLooper = Looper.myLooper();
if (mLooper == null) {//为空则抛异常
throw new RuntimeException(
"Can't create handler inside thread " + Thread.currentThread()
+ " that has not called Looper.prepare()");
}
//获取MessageQueue
mQueue = mLooper.mQueue;
mCallback = callback;
//异步先按住不表
mAsynchronous = async;
}Looper
Looper如此关键，没有就crash，看下Looper生成的过程
public static @Nullable Looper myLooper() {
return sThreadLocal.get();//ThreadLocal保证每个线程都有独立的Looper
}
//创建过程默认能退出
public static void prepare() {
prepare(true);
}
private static void prepare(boolean quitAllowed) {
//一个线程只有一个Looper
if (sThreadLocal.get() != null) {
throw new RuntimeException("Only one Looper may be created per thread");
}
sThreadLocal.set(new Looper(quitAllowed));
}
private Looper(boolean quitAllowed) {
//创建MessageQueue
mQueue = new MessageQueue(quitAllowed);
//获取当前线程
mThread = Thread.currentThread();
}
单独分析主线程也就是UI线程创建Looper过程
//主线程创建sMainLooper
public static void prepareMainLooper() {
prepare(false);
synchronized (Looper.class) {
if (sMainLooper != null) {
throw new IllegalStateException("The main Looper has already been prepared.");
}
sMainLooper = myLooper();
}
}
//ActivityThread
public static void main(String[] args) {
...
//创建主线程Looper
Looper.prepareMainLooper();
// Find the value for {@link #PROC_START_SEQ_IDENT} if provided on the command line.
// It will be in the format "seq=114"
long startSeq = 0;
if (args != null) {
for (int i = args.length - 1; i >= 0; --i) {
if (args[i] != null && args[i].startsWith(PROC_START_SEQ_IDENT)) {
startSeq = Long.parseLong(
args[i].substring(PROC_START_SEQ_IDENT.length()));
}
}
}
ActivityThread thread = new ActivityThread();
thread.attach(false, startSeq);
if (sMainThreadHandler == null) {
sMainThreadHandler = thread.getHandler();
}
if (false) {
Looper.myLooper().setMessageLogging(new
LogPrinter(Log.DEBUG, "ActivityThread"));
}
// End of event ActivityThreadMain.
Trace.traceEnd(Trace.TRACE_TAG_ACTIVITY_MANAGER);
//启动looper
Looper.loop();
//无限循环走到这说明出异常了
throw new RuntimeException("Main thread loop unexpectedly exited");
}/**
* Run the message queue in this thread. Be sure to call
* {@link #quit()} to end the loop.
*/
//官方注释要求确保要调用
public static void loop() {
final Looper me = myLooper();
if (me == null) {//必须先prepare
throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
}
final MessageQueue queue = me.mQueue;
// Make sure the identity of this thread is that of the local process,
// and keep track of what that identity token actually is.
//确保调用检查令牌权限的是当前线程
Binder.clearCallingIdentity();
final long ident = Binder.clearCallingIdentity();
// Allow overriding a threshold with a system prop. e.g.
// adb shell 'setprop log.looper.1000.main.slow 1 && stop && start'
final int thresholdOverride =
SystemProperties.getInt("log.looper."
+ Process.myUid() + "."
+ Thread.currentThread().getName()
+ ".slow", 0);
boolean slowDeliveryDetected = false;
//死循环
for (;;) {
Message msg = queue.next(); // might block
if (msg == null) {
//没消息说明正在推出
return;
}
// This must be in a local variable, in case a UI event sets the logger
//打印日志调试用
final Printer logging = me.mLogging;
if (logging != null) {
logging.println(">>>>> Dispatching to " + msg.target + " " +
msg.callback + ": " + msg.what);
}
final long traceTag = me.mTraceTag;
long slowDispatchThresholdMs = me.mSlowDispatchThresholdMs;
long slowDeliveryThresholdMs = me.mSlowDeliveryThresholdMs;
if (thresholdOverride > 0) {
slowDispatchThresholdMs = thresholdOverride;
slowDeliveryThresholdMs = thresholdOverride;
}
final boolean logSlowDelivery = (slowDeliveryThresholdMs > 0) && (msg.when > 0);
final boolean logSlowDispatch = (slowDispatchThresholdMs > 0);
final boolean needStartTime = logSlowDelivery || logSlowDispatch;
final boolean needEndTime = logSlowDispatch;
if (traceTag != 0 && Trace.isTagEnabled(traceTag)) {
Trace.traceBegin(traceTag, msg.target.getTraceName(msg));
}
final long dispatchStart = needStartTime ? SystemClock.uptimeMillis() : 0;
final long dispatchEnd;
try {
//分发
msg.target.dispatchMessage(msg);
dispatchEnd = needEndTime ? SystemClock.uptimeMillis() : 0;
} finally {
if (traceTag != 0) {//trace相关
Trace.traceEnd(traceTag);
}
}
if (logSlowDelivery) {
if (slowDeliveryDetected) {
if ((dispatchStart - msg.when) <= 10) {
Slog.w(TAG, "Drained");
slowDeliveryDetected = false;
}
} else {
if (showSlowLog(slowDeliveryThresholdMs, msg.when, dispatchStart, "delivery",
msg)) {
// Once we write a slow delivery log, suppress until the queue drains.
slowDeliveryDetected = true;
}
}
}
if (logSlowDispatch) {
showSlowLog(slowDispatchThresholdMs, dispatchStart, dispatchEnd, "dispatch", msg);
}
if (logging != null) {
logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);
}
// Make sure that during the course of dispatching the
// identity of the thread wasn't corrupted.
final long newIdent = Binder.clearCallingIdentity();
if (ident != newIdent) {
Log.wtf(TAG, "Thread identity changed from 0x"
+ Long.toHexString(ident) + " to 0x"
+ Long.toHexString(newIdent) + " while dispatching to "
+ msg.target.getClass().getName() + " "
+ msg.callback + " what=" + msg.what);
}
//回收message
msg.recycleUnchecked();
}
}MessageQueue和Message
public final class Message implements Parcelable {//继承自Parcelable
public int what;
public Object obj;
//下面的是访问权限是包内
/*package*/ int flags;
/*package*/ long when;
/*package*/ Bundle data;
/*package*/ Handler target;
/*package*/ Runnable callback;
// sometimes we store linked lists of these things
/*package*/ Message next;
/** @hide */
//下面是static修饰的
public static final Object sPoolSync = new Object();//同步锁
private static Message sPool;
private static int sPoolSize = 0;
private static final int MAX_POOL_SIZE = 50;//数据池最大size
public Message() {
}
//生成Message的时候最终都是调用obtain
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;//返回当前sPool，然后挪动next指针
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--;
return m;
}
}
return new 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();
}
/**
* Recycles a Message that may be in-use.
* Used internally by the MessageQueue and Looper when disposing of queued Messages.
*/
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++;
}
}
}
}这里我们知道了message的数据结构是通过next串联起来的，并且最好使用obtain而避免自己new，可以提高性能。
然后是MessageQueue
public final class MessageQueue {
//能否退出
private final boolean mQuitAllowed;
@SuppressWarnings("unused")
private long mPtr; //native用的
Message mMessages;
private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>();
private SparseArray<FileDescriptorRecord> mFileDescriptorRecords;
private IdleHandler[] mPendingIdleHandlers;
private boolean mQuitting;
// Indicates whether next() is blocked waiting in pollOnce() with a non-zero timeout.
private boolean mBlocked;
// The next barrier token.
// Barriers are indicated by messages with a null target whose arg1 field carries the token.
private int mNextBarrierToken;
//下面这些都是native方法，暂时不深究
private native static long nativeInit();
private native static void nativeDestroy(long ptr);
private native void nativePollOnce(long ptr, int timeoutMillis); /*non-static for callbacks*/
private native static void nativeWake(long ptr);
private native static boolean nativeIsPolling(long ptr);
private native static void nativeSetFileDescriptorEvents(long ptr, int fd, int events);
MessageQueue(boolean quitAllowed) {
//主线程不允许退出，子线程允许
mQuitAllowed = quitAllowed;
//记录消息队列
mPtr = nativeInit();
}next方法信息量比较大
Message next() {
final long ptr = mPtr;
if (ptr == 0) {// message的loop已经退出而且执行了disposed.
return null;
}
int pendingIdleHandlerCount = -1; // 只有第一次是-1
int nextPollTimeoutMillis = 0;
for (;;) {//又是一个死循环
if (nextPollTimeoutMillis != 0) {
Binder.flushPendingCommands();
}
//阻塞方法，会被wake唤醒，也可以在nextPollTimeoutMillis时间后唤醒
//nextPollTimeoutMillis是0立即返回，-1就阻塞，否则等到nextPollTimeoutMillis时间后返回
nativePollOnce(ptr, nextPollTimeoutMillis);
//加锁
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) {
//这里target是null，说明遇到了barrier
do {
prevMsg = msg;//如果执行了这里
msg = msg.next;
} while (msg != null && !msg.isAsynchronous());//找到下一个异步消息为止
}
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赋值，说明找到了异步消息，则重新链接message表
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.没信息重置为1
nextPollTimeoutMillis = -1;
}
// Process the quit message now that all pending messages have been handled.
if (mQuitting) {
dispose();
return null;
}
// If first time idle, then get the number of idlers to run.
// Idle handles only run if the queue is empty or if the first message
// in the queue (possibly a barrier) is due to be handled in the future.
if (pendingIdleHandlerCount < 0//循环第一次能走到这
&& (mMessages == null || now < mMessages.when)) {//当前没有消息
pendingIdleHandlerCount = mIdleHandlers.size();
}
//如果依然是-1说明不能执行IdleHandler，所以block，跳出循环，如果nextPollTimeoutMillis也是-1则回到之前的nativepullonce
if (pendingIdleHandlerCount <= 0) {
// No idle handlers to run. Loop and wait some more.
mBlocked = true;
continue;
}
//初始化最少4个handlers
if (mPendingIdleHandlers == null) {
mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
}
mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
}
// Run the idle handlers.
// We only ever reach this code block during the first iteration.
for (int i = 0; i < pendingIdleHandlerCount; i++) {
final IdleHandler idler = mPendingIdleHandlers[i];
mPendingIdleHandlers[i] = null; // release the reference to the handler
boolean keep = false;
try {
keep = idler.queueIdle();//执行具体的queueIdle
} catch (Throwable t) {
Log.wtf(TAG, "IdleHandler threw exception", t);
}
if (!keep) {//如果返回true则remove，否则无限循环
synchronized (this) {
mIdleHandlers.remove(idler);
}
}
}
// Reset the idle handler count to 0 so we do not run them again.
//重置，所以之后就不会再执行了
pendingIdleHandlerCount = 0;
// While calling an idle handler, a new message could have been delivered
// so go back and look again for a pending message without waiting.
//有可能有普通消息过来，直接设置0，不等待进入下次循环
nextPollTimeoutMillis = 0;
}
}看完了next出列，接下来看enqueueMessage入列。
boolean enqueueMessage(Message msg, long when) {
//两个必要的检查，为什么必须有target？刚才next还有没有target的情况，晚点再返回来看
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) {
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;
Message p = mMessages;
boolean needWake;
if (p == null || when == 0 || when < p.when) {//之前没有消息或者已经到了触发时间
//新入列的插入头部
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.
//是否唤醒需要看target异步消息
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;
}
// We can assume mPtr != 0 because mQuitting is false.
if (needWake) {
nativeWake(mPtr);//唤醒
}
}
return true;
}接下来看一下同步屏障是什么
public int postSyncBarrier() {
return postSyncBarrier(SystemClock.uptimeMillis());//同步屏障是隐藏方法，且只支持当前时间
}
private int postSyncBarrier(long when) {//这里的message没有target
// Enqueue a new sync barrier token.
// We don't need to wake the queue because the purpose of a barrier is to stall it.
synchronized (this) {
final int token = mNextBarrierToken++;
final Message msg = Message.obtain();
msg.markInUse();
msg.when = when;
msg.arg1 = token;
Message prev = null;
Message p = mMessages;
if (when != 0) {
while (p != null && p.when <= when) {
prev = p;
p = p.next;
}
}
if (prev != null) { // invariant: p == prev.next//插入合适的位置
msg.next = p;
prev.next = msg;
} else {
msg.next = p;
mMessages = msg;
}
return token;
}
}然后是移除同步屏障
public void removeSyncBarrier(int token) {
// Remove a sync barrier token from the queue.
// If the queue is no longer stalled by a barrier then wake it.
synchronized (this) {
Message prev = null;
Message p = mMessages;
while (p != null && (p.target != null || p.arg1 != token)) {
prev = p;
p = p.next;
}
if (p == null) {//没找到就崩溃
throw new IllegalStateException("The specified message queue synchronization "
+ " barrier token has not been posted or has already been removed.");
}
final boolean needWake;
if (prev != null) {
prev.next = p.next;
needWake = false;//之前还有其他消息不唤醒
} else {
mMessages = p.next;
needWake = mMessages == null || mMessages.target != null;//看当前消息再决定是否唤醒
}
p.recycleUnchecked();//回收
// If the loop is quitting then it is already awake.
// We can assume mPtr != 0 when mQuitting is false.
if (needWake && !mQuitting) {
nativeWake(mPtr);
}
}
}小结：
next的时候，假设有同步屏障，接下来只取异步消息，同步消息全部等待，来保证异步消息尽快执行。查看调用，使用同步屏障的地方主要在编舞者等系统关键时刻。消息的入队和出队在这基本分析完了，接下来是事件分发。
消息分发
Looper中调用了msg.target.dispatchMessage，具体看下
public void dispatchMessage(Message msg) {
if (msg.callback != null) {//先判断msg是否有callback，有就执行handleCallback
handleCallback(msg);
} else {
if (mCallback != null) {//否则调用handler的callback
if (mCallback.handleMessage(msg)) {
return;
}
}
handleMessage(msg);//没人处理走这
}
}
/**
* Subclasses must implement this to receive messages.
*/
public void handleMessage(Message msg) {
}还有时间发送的post
public final boolean post(Runnable r)
{
return sendMessageDelayed(getPostMessage(r), 0);
}
public final boolean postAtTime(Runnable r, long uptimeMillis)
{
return sendMessageAtTime(getPostMessage(r), uptimeMillis);
}
public final boolean postAtTime(Runnable r, Object token, long uptimeMillis)
{
return sendMessageAtTime(getPostMessage(r, token), uptimeMillis);
}
//最终都执行这个，传入两个必备的参数，Message和时间
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);
}总结
分工
Message：消息本身，存储一些target，data之类的数据
MessageQueue：消息队列主要维护消息，取出next或者插入数据enqueueMessage，也维护同步屏障异步消息等逻辑。
Looper：维持线程和Looper循环对应关系，分发到对应的msg。
Handler：负责发送和处理最终事件逻辑。
系统UI相关
同步屏障：加入同步屏障后，同步消息全部阻塞，异步消息能正常执行。
异步消息：可以理解为紧急消息，避免因为同步消息过多导致执行不及时。
使用在编舞者等系统UI关键操作中，避免消息过多导致系统关键操作卡顿。
本地方法
nativePollOnce：维持主线程不退出，并且阻塞逻辑，不占用CPU资源
nativeWake：适当时机唤醒循环
更多native方法逻辑，后续整理再发
以上是关于Handler源码的主要内容，如果未能解决你的问题，请参考以下文章