@Override
public void run() {
    mTid = Process.myTid();
    Looper.prepare();                  // ① 创建该线程的 Looper 和 MessageQueue
    synchronized (this) {
        mLooper = Looper.myLooper();
        notifyAll();                   // ② 唤醒在 getLooper() 中等待的线程
    }
    Process.setThreadPriority(mPriority);
    onLooperPrepared();                // ③ 回调：Looper 就绪，可以做初始化
    Looper.loop();                     // ④ 进入死循环，处理消息
    mTid = -1;
}

public class HandlerThread extends Thread {
    int mPriority;                              // 线程优先级
    int mTid = -1;                              // 线程 ID
    Looper mLooper;                             // 该线程的 Looper
    private volatile @Nullable Handler mHandler; // 共享 Handler
    private volatile @Nullable Executor mExecutor; // 共享 Executor
}

// 默认优先级
public HandlerThread(String name) {
    super(name);
    mPriority = Process.THREAD_PRIORITY_DEFAULT;  // 行 92-96
}

// 自定义优先级
public HandlerThread(String name, int priority) {
    super(name);
    mPriority = priority;                          // 行 104-108
}

// HandlerThread.java:149
public Looper getLooper() {
    if (!isAlive()) return null;

    boolean wasInterrupted = false;

    synchronized (this) {
        while (isAlive() && mLooper == null) {
            wait();           // 阻塞等待 run() 中 notifyAll()
        }
    }

    if (wasInterrupted) {
        Thread.currentThread().interrupt();
    }

    return mLooper;
}

// 行 183: 获取与该线程关联的共享 Handler
public Handler getThreadHandler() {
    if (mHandler == null) {
        mHandler = new Handler(getLooper());
    }
    return mHandler;
}

// 行 195: 获取与该线程关联的共享 Executor
public Executor getThreadExecutor() {
    if (mExecutor == null) {
        mExecutor = new HandlerExecutor(getThreadHandler());
    }
    return mExecutor;
}

// 行 224: 立即退出
public boolean quit() {
    Looper looper = getLooper();
    if (looper != null) {
        looper.quit();
        return true;
    }
    return false;
}

// 行 254: 安全退出（推荐）
public boolean quitSafely() {
    Looper looper = getLooper();
    if (looper != null) {
        looper.quitSafely();
        return true;
    }
    return false;
}

// 行 126: 子类可重写，在 Looper 开始循环前执行初始化
protected void onLooperPrepared() {
}

public class ServiceThread extends HandlerThread {
    private final boolean mAllowIo;

    public ServiceThread(String name, int priority, boolean allowIo) {
        super(name, priority);
        mAllowIo = allowIo;
    }

    @Override
    public void run() {
        if (!mAllowIo) {
            StrictMode.initThreadDefaults(null);  // 禁止 IO 操作时启用 StrictMode 检测
        }
        super.run();
    }
}

public final class DisplayThread extends ServiceThread {
    private static DisplayThread sInstance;
    private static Handler sHandler;

    private DisplayThread() {
        // 优先级仅次于 AnimationThread
        super("android.display", Process.THREAD_PRIORITY_DISPLAY + 1, false);
    }

    private static void ensureThreadLocked() {
        if (sInstance == null) {
            sInstance = new DisplayThread();
            sInstance.start();
            sInstance.getLooper().setTraceTag(Trace.TRACE_TAG_SYSTEM_SERVER);
            sHandler = makeSharedHandler(sInstance.getLooper());
        }
    }

    public static Handler getHandler() {
        synchronized (DisplayThread.class) {
            ensureThreadLocked();
            return sHandler;
        }
    }
}

// 创建
mHandlerThread = new ServiceThread(TAG, priority, allowIo);
mHandlerThread.start();
mHandler = new Handler(mHandlerThread.getLooper());

// 使用
mHandler.sendMessage(msg);
mHandler.post(() -> doWork());
mHandler.postDelayed(() -> doDelayedWork(), 1000);

// 退出
mHandlerThread.quitSafely();