掌握Android Handler消息机制核心代码

Handler handler = new Handler(){
    @Override
    public void handleMessage(@NonNull Message msg) {                     
        super.handleMessage(msg);
    }
};
Message message = new Message();
handler.sendMessage(message);

private static Message getPostMessage(Runnable r) {
    Message m = Message.obtain();
    m.callback = r;
    return m;
}

sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);

private boolean enqueueMessage(@NonNull MessageQueue queue, @NonNull Message msg,
            long uptimeMillis) {
        msg.target = this;
        msg.workSourceUid = ThreadLocalWorkSource.getUid();

        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }

boolean enqueueMessage(Message msg, long when) {
    if (msg.target == null) {
     throw new IllegalArgumentException("Message must have a target.");
    }
    //...省略下文代码
}    

boolean enqueueMessage(Message msg, long when) {
    //...省略上文代码
    synchronized (this) {
        if (msg.isInUse()) {
            throw new IllegalStateException(msg + " This message is already in use.");
        }
        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;
        //...省略下文代码
    }
    //...省略下文代码
}

boolean enqueueMessage(Message msg, long when) {
    //...省略上文代码
    synchronized (this) {
            //...省略上文代码
            //步骤1
            Message p = mMessages;
            boolean needWake;
            //步骤2
            if (p == null || when == 0 || when < p.when) {
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                needWake = mBlocked && p.target == null && msg.isAsynchronous();
                //步骤3
                Message prev;
                for (;;) {
                    prev = p;
                    p = p.next;
                    if (p == null || when < p.when) {
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        needWake = false;
                    }
                }
                msg.next = p;
                prev.next = msg;
            }
            
            if (needWake) {
                nativeWake(mPtr);
            }
    }
    //步骤4
    return true;
}

 public static void loop() {
   //获取loop对象
        final Looper me = myLooper();
        if (me == null) {
         //若loop为空，则抛出异常终止操作
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        if (me.mInLoop) {
         //loop循环重复开启
            Slog.w(TAG, "Loop again would have the queued messages be executed"
                    + " before this one completed.");
        }
        //标记当前loop已经开启
        me.mInLoop = true;
        //获取消息队列
        final MessageQueue queue = me.mQueue;
        //确保权限检查基于本地进程,
        Binder.clearCallingIdentity();
        final long ident = Binder.clearCallingIdentity();
        final int thresholdOverride =
                SystemProperties.getInt("log.looper."
                        + Process.myUid() + "."
                        + Thread.currentThread().getName()
                        + ".slow", 0);
        boolean slowDeliveryDetected = false;
        //...省略下文代码
}        

 public static void loop() {
   //...省略上文代码
   for (;;) {
    //步骤一
            Message msg = queue.next();
            if (msg == null) {
                //步骤二
                return;
            }
           //...省略非核心代码
            try {
             //步骤三
                msg.target.dispatchMessage(msg);
                //...
            } catch (Exception exception) {
                //...省略非核心代码
            } finally {
                //...省略非核心代码
            }
            //步骤四
            msg.recycleUnchecked();
        }
}        

Message next() {
 //步骤一
 final long ptr = mPtr;
    if (ptr == 0) {
  return null;
 }
 //步骤二
 int pendingIdleHandlerCount = -1; 
 //步骤三
 int nextPollTimeoutMillis = 0;
 //...省略下文代码
} 

Message next() {
 //...省略上文代码
 for(;;){
  if (nextPollTimeoutMillis != 0) {
   Binder.flushPendinGCommands();
  }
  nativePollOnce(ptr, nextPollTimeoutMillis);
  //...省略下文代码  
 }
} 

Message next() {
 //...省略上文代码
 for(;;){
  //...省略上文代码
       //开启同步锁
  synchronized (this) {
   final long now = SystemClock.uptimeMillis();     
                //步骤一
                Message prevMsg = null;
                Message msg = mMessages;
                //步骤二
                if (msg != null && msg.target == null) {
                    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 {
                        //步骤五
                        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;
                }
  } 
  //...省略下文IdleHandler相关代码  
 }
} 

public void dispatchMessage(@NonNull Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();

public static void prepare() {
        prepare(true);
    }
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));
    }
private Looper(boolean quitAllowed) {
        mQueue = new MessageQueue(quitAllowed);
        mThread = Thread.currentThread();
    }    

public static @Nullable Looper myLooper() {
        return sThreadLocal.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();
    }
    
ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }    

 public Handler(@NonNull Looper looper, @Nullable Callback callback, boolean async) {
        mLooper = looper;
        mQueue = looper.mQueue;
        mCallback = callback;
        mAsynchronous = async;
    }
public Handler(@Nullable 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) {
         //注意这个异常，loop不能为空的，首先要Looper.prepare()；
            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 static final Object sPoolSync = new Object();
Message next;
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();
    }

public static final Object sPoolSync = new Object();
private static final int MAX_POOL_SIZE = 50;

void recycleUnchecked() {
        flags = FLAG_IN_USE;
        what = 0;
        arg1 = 0;
        arg2 = 0;
        obj = null;
        replyTo = null;
        sendingUid = UID_NONE;
        workSourceUid = UID_NONE;
        when = 0;
        target = null;
        callback = null;
        data = null;

        synchronized (sPoolSync) {
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }

  public static interface IdleHandler {
        boolean queueIdle();
    }

Looper.getMainLooper().getQueue().addIdleHandler(new MessageQueue.IdleHandler() {
            @Override
            public boolean queueIdle() {
                return true;
            }
        });

private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>();

 public void addIdleHandler(@NonNull IdleHandler handler) {
        if (handler == null) {
            throw new NullPointerException("Can't add a null IdleHandler");
        }
        synchronized (this) {
            mIdleHandlers.add(handler);
        }
    }

Message next() {
        
        //...省略不相关代码

        //步骤一
        int pendingIdleHandlerCount = -1; // -1 只存在第一次迭代中
        for (;;) {
                //...省略不相关代码

                //步骤二
                if (pendingIdleHandlerCount < 0
                        && (mMessages == null || now < mMessages.when)) {
                    pendingIdleHandlerCount = mIdleHandlers.size();
                }

                //步骤三
                if (pendingIdleHandlerCount <= 0) {
                    // No idle handlers to run.  Loop and wait some more.
                    mBlocked = true;
                    continue;
                }

                //步骤四
                if (mPendingIdleHandlers == null) {
                    mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
                }
                mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
            }

        
            //步骤五
            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();
                } catch (Throwable t) {
                    Log.wtf(TAG, "IdleHandler threw exception", t);
                }

                //步骤七
                if (!keep) {
                    synchronized (this) {
                        mIdleHandlers.remove(idler);
                    }
                }
            }

            //步骤八
            pendingIdleHandlerCount = 0;
        }
    }