白话说Handler-MessageQueue-Looper

//{@link android.app.ActivityThread}
public static void main(String[] args) {
        //  ... something for environment & log
        
        Looper.prepareMainLooper();
        
        // init ActivityThread; ActivityManager.attachApplication
        // init Instrumentation; ContextImpl.createAppContext
        // context.mPackageInfo.makeApplication; application.onCreate
        // and so on ...
        
        Looper.loop();
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

// {@link android.os.Looper#prepare()}
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();
}

final MessageQueue mQueue;

// {@link android.os.Looper#loop()}
public static void loop() {
    final Looper me = myLooper();
    if (me == null) {
        throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
    }
    final MessageQueue queue = me.mQueue;

    // something for Binder

    for (;;) {
        Message msg = queue.next(); // might block
        if (msg == null) {
            // No message indicates that the message queue is quitting.
            return;
        }
        
        // ... something for log
        // 执行Handler.Callback.handleMessage
        msg.target.dispatchMessage(msg);
        
        // something for log
        
        msg.recycleUnchecked();
    }
}

myHandler.sendMessage(message);

Message next() {
       int nextPollTimeoutMillis = 0;
       for (;;) {
           if (nextPollTimeoutMillis != 0) {
               Binder.flushPendingCommands();
           }
           
           nativePollOnce(ptr, nextPollTimeoutMillis);

           synchronized (this) {
               final long now = SystemClock.uptimeMillis();
               Message prevMsg = null;
               Message msg = mMessages;
               // msg.target == null 源自{@link #postSyncBarrier}
               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;
                       msg.markInUse();
                       return msg;
                   }
               } else {
                   // No more messages.
                   nextPollTimeoutMillis = -1;
               }

               if (mQuitting) {
                   dispose();
                   return null;
               }

               // ... 队列为空或无可消费对象时相关逻辑
           }
           // ... 队列为空或无可消费对象时，状态重置、调用闲置回调
       }
   }

public class MainActivity extends AppCompatActivity {
    public static final String TAG = "HandlerTest";
    ScheduledExecutorService executorService = new ScheduledThreadPoolExecutor(5,
            new ThreadFactory() {
                @Override
                public Thread newThread(Runnable r) {
                    Thread thread = new Thread(r);
                    thread.setName("test-Thread");
                    return thread;
                }
            });

    Handler myHandler = new MyHandler(Looper.getMainLooper());

    Runnable taskRunnable = new Runnable() {
        @Override
        public void run() {
            myHandler.sendEmptyMessage(1);
            MyHandler handler = new MyHandler(subThread.getLooper());
            handler.sendEmptyMessage(3);
        }
    };

    HandlerThread subThread = new HandlerThread("test-Thread2");

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        subThread.start();
        executorService.schedule(taskRunnable, 3, TimeUnit.SECONDS);

        myHandler.postDelayed(new Runnable() {
            @Override
            public void run() {
                MyHandler handler = new MyHandler(subThread.getLooper());
                handler.sendEmptyMessage(2);
            }
        },1000);
    }

    static class MyHandler extends Handler {

        public MyHandler(@NonNull Looper looper) {
            super(looper);
        }

        @Override
        public void handleMessage(@NonNull Message msg) {
            // doSomething
            Log.i(TAG, String.format("ThreadName: %s, msg.what = %s",
                    Thread.currentThread().getName(), msg.what));
        }
    }

}