public class HandlerActivity extends ActivityBase{
    ActivityHandlerBinding binding ;
    private Handler handler = new Handler(new Handler.Callback() {
        @Override
        public boolean handleMessage(@NonNull Message msg) {
            switch (msg.what){
                case 1:
                    binding.tvTotle.setText(String.format("哈哈哈哈考了%d",msg.arg1));
                    break;
            }
            return false;
        }
    });
    @Override
    protected void onCreate(@Nullable @org.jetbrains.annotations.Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        binding = ActivityHandlerBinding.inflate(getLayoutInflater());
        setContentView(binding.getRoot());
        binding.btnSendMessage.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Message msg = new Message();
                msg.what=1;
                msg.arg1=100;
                handler.sendMessage(msg);
            }
        });
        binding.btnPost.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                handler.post(new Runnable() {
                    @Override
                    public void run() {
                        binding.tvTotle.setText(String.format("哈哈哈哈考了%d",80));
                    }
                });
            }
        });
    }
}

public final boolean post(@NonNull Runnable r) {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }

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

public final boolean sendMessage(@NonNull Message msg) {
        return sendMessageDelayed(msg, 0);
    }

    /**
     * Handle system messages here.
     * 在这里处理系统消息。
     */
    public void dispatchMessage(@NonNull Message msg) {
        //注释1
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
        //注释2
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

    private static void handleCallback(Message message) {
        message.callback.run();
    }

    Message next() {
        // mPtr ：used by native code
        final long ptr = mPtr;
        if (ptr == 0) {
            return null;
        }
        //-1：仅在第一次迭代期间
        int pendingIdleHandlerCount = -1; 
        //下一个Poll超时时间
        int nextPollTimeoutMillis = 0;
        for (;;) {
            if (nextPollTimeoutMillis != 0) {
                //将当前线程中挂起的所有 Binder 命令刷新到内核驱动程序。 
                //在执行可能会阻塞很长时间的操作之前调用这会很有用，
                //以确保任何挂起的对象引用都已被释放，以防止进程持有对象的时间超过它所需的时间。
                Binder.flushPendingCommands();
            }
            //注释：重点来了。
            nativePollOnce(ptr, nextPollTimeoutMillis);
            ...
        }
    }

/*non-static for callbacks*/
    private native void nativePollOnce(long ptr, int timeoutMillis);

static void android_os_MessageQueue_nativePollOnce(JNIEnv* env, jobject obj,
        jlong ptr, jint timeoutMillis) {
    NativeMessageQueue* nativeMessageQueue = reinterpret_cast<NativeMessageQueue*>(ptr);
     //取出NativeMessageQueue对象，并调用它的pollOnce
    nativeMessageQueue->pollOnce(env, obj, timeoutMillis);
}

/**
     * 等待事件可用，以毫秒为单位可选超时。
     * 为发生事件的所有文件描述符调用回调。
     * 如果超时为零，则立即返回而不阻塞。
     * 如果超时为负，则无限期等待直到事件出现。
     * 如果之前使用wake() 唤醒轮询，则返回POLL_WAKE
     * 超时到期，没有调用回调，也没有其他文件
     * 描述符已准备就绪。
     * 如果调用了一个或多个回调，则返回 POLL_CALLBACK。
     * 如果在给定之前没有数据等待超时，则返回 POLL_TIMEOUT。
     * 如果等待过程中发生错误，则返回 POLL_ERROR。
     * 如果文件描述符有数据，则返回一个 >= 0 包含标识符的值
     * 并且它没有回调函数（这里需要调用者来处理它）。
     * 在这个（并且只有这个）情况下，outFd、outEvents 和 outData 将包含投票
     * 与 fd 关联的事件和数据，否则它们将被设置为 NULL。
     *
     * 此方法在完成调用适当的回调之前不会返回
     * 用于所有已发出信号的文件描述符。
     */
    int pollOnce(int timeoutMillis, int* outFd, int* outEvents, void** outData);
    inline int pollOnce(int timeoutMillis) {
        //timeOutMillis参数为超时等待时间。如果为-1，则表示无限等待，直到有事件发生为止。如果值为0，则无需等待立即返回。
        return pollOnce(timeoutMillis, nullptr, nullptr, nullptr);
    }

Message next() {
        ...
        for (;;) {
            ...
            nativePollOnce(ptr, nextPollTimeoutMillis);
            synchronized (this) {
                // 尝试检索下一条消息。 找到就返回。
                //获取系统时间。
                final long now = SystemClock.uptimeMillis();
                Message prevMsg = null;
                Message msg = mMessages;
                if (msg != null) {
                    if (now < msg.when) {
                        // 下一条消息未准备好。 设置超时以在准备好时唤醒。
                        nextPollTimeoutMillis = (int) Math.min(msg.when - now, Integer.MAX_VALUE);
                    } else {
                        // 收到一条消息。
                        //mBlocked：指示 next() 是否在 pollOnce() 中以非零超时阻塞等待。
                        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();
                        //返回 Message 
                        return msg;
                    }
                } else {
                    // 没有更多的消息。
                    nextPollTimeoutMillis = -1;
                }
            }
        }
    }