Handler

// 主线程中创建 Handler
private Handler mHandler = new Handler(Looper.getMainLooper()) {
    @Override
    public void handleMessage(@NonNull Message msg) {
        // 步骤 5：处理消息（主线程中执行）
        switch (msg.what) {
            case 1:
                String data = (String) msg.obj;
                textView.setText(data); // 安全更新 UI
                break;
        }
    }
};

// 子线程中发送消息
new Thread(() -> {
    // 模拟耗时操作（如网络请求）
    String result = "从服务器获取的数据";
    
    // 方式 1：发送 Message 对象
    Message msg = Message.obtain(); // 推荐：复用 Message 池，避免内存浪费
    msg.what = 1; // 消息标识（用于区分不同消息）
    msg.obj = result; // 传递数据
    mHandler.sendMessage(msg); // 将消息加入主线程的 MessageQueue
    
    // 方式 2：通过 post() 发送 Runnable（本质也是封装成 Message）
    mHandler.post(() -> {
        textView.setText(result); // Runnable 会在主线程执行
    });
}).start();

public static void loop() {
    Looper me = myLooper(); // 获取当前线程的 Looper
    MessageQueue queue = me.mQueue; // 获取 Looper 绑定的 MessageQueue
    
    while (true) { // 无限循环
        // 1. 从队列中取出消息（若队列空，会阻塞等待）
        Message msg = queue.next(); 
        if (msg == null) {
            return; // 队列退出，循环结束（主线程一般不会触发）
        }
        
        // 2. 将消息分发给对应的 Handler（msg.target 即发送消息的 Handler）
        msg.target.dispatchMessage(msg);
        
        // 3. 回收消息到 Message 池（复用，减少 GC）
        msg.recycleUnchecked();
    }
}

public void dispatchMessage(@NonNull Message msg) {
    if (msg.callback != null) {
        // 1. 若 Message 有 callback（即 post() 传递的 Runnable），直接执行
        handleCallback(msg); 
    } else {
        if (mCallback != null) {
            // 2. 若 Handler 构造时传入了 Callback，执行 Callback 的 handleMessage()
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        // 3. 最后执行 Handler 重写的 handleMessage()
        handleMessage(msg);
    }
}

// 3 秒后执行 Runnable（主线程中）
mHandler.postDelayed(() -> {
    dialog.dismiss(); // 延迟关闭弹窗
}, 3000); // 延迟时间：3000ms = 3秒

private int count = 10;
private void startCountdown() {
    mHandler.postDelayed(() -> {
        textView.setText("倒计时：" + count--);
        if (count >= 0) {
            startCountdown(); // 再次发送延迟任务，实现循环
        }
    }, 1000);
}

boolean enqueueMessage(Message msg, long when) {
    
    ...

    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) {
            // 队列里无消息，或插入消息的执行时间为0（强制插入队头），或插入消息的执行
            // 时间先于队头消息，这三种情况下插入消息为新队头，如果队列被阻塞则将其唤醒
            msg.next = p;
            mMessages = msg;
            needWake = mBlocked;
        } else {
            // 根据执行时间将消息插入到队列中间。通常我们不必唤醒事件队列，除非
            // 队列头部有消息屏障阻塞队列，并且插入的消息是队列中第一个异步消息
            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;
            prev.next = msg;
        }
        
        // We can assume mPtr != 0 because mQuitting is false.
        if (needWake) {
            // Native方法唤醒等待的线程
            nativeWake(mPtr);
        }
    }
    return true;
}

Message next() {
    
    ...

    int pendingIdleHandlerCount = -1; // -1 only during first iteration
    int nextPollTimeoutMillis = 0;
    for (;;) {
        if (nextPollTimeoutMillis != 0) {
            Binder.flushPendingCommands();
        }
        
        // 通过native层的MessageQueue阻塞nextPollTimeoutMillis毫秒时间
        nativePollOnce(ptr, nextPollTimeoutMillis);
        
        synchronized (this) {
            // 尝试检索下一个消息，如果找到则返回该消息
            final long now = SystemClock.uptimeMillis();
            Message prevMsg = null;
            Message msg = mMessages;
            if (msg != null && msg.target == null) {
                // 被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数量
            // 仅当队列为空或者队列中的第一条消息（可能是同步屏障）
            // 还没到执行时间时，才会执行IdleHandler
            if (pendingIdleHandlerCount < 0
                    && (mMessages == null || now < mMessages.when)) {
                pendingIdleHandlerCount = mIdleHandlers.size();
            }
            if (pendingIdleHandlerCount <= 0) {
                // 如果没有IdleHandler需要执行，那么就阻塞等待下一个消息到来
                mBlocked = true;
                continue;
            }
            
            if (mPendingIdleHandlers == null) {
                mPendingIdleHandlers = new IdleHandler[Math.max(pendingIdleHandlerCount, 4)];
            }
            mPendingIdleHandlers = mIdleHandlers.toArray(mPendingIdleHandlers);
        }
        
        // 运行IdleHandler
        // 执行一次next方法只有第一次轮询能执行这里的操作
        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 {
                // 执行IdleHandler，返回是否保留IdleHandler
                keep = idler.queueIdle();
            } catch (Throwable t) {
                Log.wtf(TAG, "IdleHandler threw exception", t);
            }
            
            if (!keep) {
                synchronized (this) {
                    // 如果不需要保留，则移除这个IdleHandler
                    mIdleHandlers.remove(idler);
                }
            }
        }
        
        // 设置为0保证在再次执行next方法之前不会再执行IdleHandler
        pendingIdleHandlerCount = 0;
        
        // 当调用一个IdleHandler执行后，无需等待直接再次检索一次消息队列
        nextPollTimeoutMillis = 0;
    }
}

public static Message obtain() {
    synchronized (sPoolSync) {
      if (sPool != null) {
        Message m = sPool;
        sPool = m.next;
        m.next = null; //从sPool中取出一个Message对象，并消息链表断开
        m.flags = 0; // clear in-use flag清除in-use flag
        sPoolSize--;//消息池的可用大小进行-1操作
        return m;
      }
    }
    return new Message();// 当消息池为空时，直接创建Message对象
}

public interface IdleHandler {
    /**
     * 消息队列空闲时回调
     * @param remainingIdleTimeMillis 预估的空闲时间（毫秒），-1 表示无更多消息
     * @return true：保留此 IdleHandler，下次空闲时继续回调；false：执行后移除
     */
    boolean queueIdle(long remainingIdleTimeMillis);
}

// 获取主线程的 MessageQueue
MessageQueue queue = Looper.myQueue();

// 创建 IdleHandler 实例
IdleHandler myIdleHandler = remainingIdleTime -> {
    // 执行空闲任务（如预加载）
    preloadNextPageData();
    
    // 返回 false：执行一次后移除；true：保留，下次空闲继续执行
    return false;
};

// 注册 IdleHandler
queue.addIdleHandler(myIdleHandler);

// （可选）在不需要时移除（如页面销毁）
// queue.removeIdleHandler(myIdleHandler);

Message next() {
    int pendingIdleHandlerCount = -1;
    int nextPollTimeoutMillis = 0;

    for (;;) { // 消息队列的主循环
        // 1. 阻塞等待消息（根据 nextPollTimeoutMillis 决定等待时间）
        nativePollOnce(ptr, nextPollTimeoutMillis);

        synchronized (this) {
            // 2. 检查是否有即时消息（已到执行时间的消息）
            long now = SystemClock.uptimeMillis();
            Message msg = mMessages;
            if (msg != null && msg.when <= now) {
                // 有即时消息：取出并返回，退出本次循环
                return msg;
            } else {
                // 无即时消息：准备执行 IdleHandler
                pendingIdleHandlerCount = mIdleHandlers.size();
            }
        }

        // 3. 执行所有 IdleHandler（仅当队列空闲时）
        if (pendingIdleHandlerCount > 0) {
            for (int i = 0; i < pendingIdleHandlerCount; i++) {
                final IdleHandler idler = mIdleHandlers.get(i);
                // 调用回调，返回值决定是否保留
                boolean keep = idler.queueIdle(nextPollTimeoutMillis);
                if (!keep) {
                    mIdleHandlers.remove(i); // 不保留则移除
                }
            }
            pendingIdleHandlerCount = 0;
        }

        // 4. 计算下次阻塞等待的时间（根据延迟消息的剩余时间）
        nextPollTimeoutMillis = calculatePollTimeout();
        if (nextPollTimeoutMillis != 0) {
            // 有延迟消息：跳出循环，进入阻塞等待
            break;
        }
        // 无延迟消息：继续循环（但此时队列已空，最终会阻塞）
    }
}

Looper.myQueue().addIdleHandler(remainingTime -> {
    System.out.println("IdleHandler 执行，剩余空闲时间：" + remainingTime);
    return true; // 保留回调，期望重复执行
});

// 1秒后发送一条消息（模拟用户操作）
new Handler(Looper.getMainLooper()).postDelayed(() -> {
    System.out.println("收到新消息，处理中...");
}, 1000);

// ActivityThread 中处理 Activity 启动的逻辑
private void handleLaunchActivity(ActivityClientRecord r, Intent customIntent) {
    // 1. 执行 Activity 启动的核心流程（onCreate、onStart 等）
    Activity a = performLaunchActivity(r, customIntent);
    if (a != null) {
        // 2. 启动完成后，注册 IdleHandler 处理后续任务
        Looper.myQueue().addIdleHandler(new IdleHandler() {
            @Override
            public boolean queueIdle(long remainingIdleTimeMillis) {
                // 3. 空闲时执行：如清理启动临时资源、报告启动完成事件
                r.activity.performPostLaunchProcessing();
                // 4. 执行一次后移除
                return false;
            }
        });
    }
}

// ViewRootImpl 中触发 View 绘制的逻辑
void performTraversals() {
    // 1. 执行 View 绘制流程（measure、layout、draw）
    performMeasure();
    performLayout();
    performDraw();
    
    // 2. 绘制完成后，注册 IdleHandler 处理后续优化
    mChoreographer.postIdleMessage(new Runnable() {
        @Override
        public void run() {
            // 3. 空闲时执行：如回收绘制临时对象、统计绘制耗时
            cleanupAfterDraw();
            reportDrawPerformance();
        }
    });
    // （注：Choreographer 的 postIdleMessage 内部依赖 IdleHandler 实现）
}

// 资源缓存管理类
class ResourceCache {
    private final LruCache<String, Resource> mCache = new LruCache<>(100);
    
    public ResourceCache() {
        // 注册 IdleHandler 定期清理过期资源
        Looper.myQueue().addIdleHandler(new IdleHandler() {
            @Override
            public boolean queueIdle(long remainingIdleTimeMillis) {
                // 1. 清理超过 5 分钟未使用的资源
                mCache.trimToSize(50); // 缩小缓存容量
                // 2. 保留回调，下次空闲继续检查
                return true;
            }
        });
    }
}

// 通知展示后的处理
private void postNotification(StatusBarNotification sbn) {
    // 1. 优先展示通知（关键操作）
    mStatusBar.showNotification(sbn);
    
    // 2. 注册 IdleHandler 记录曝光日志（非紧急）
    Looper.myQueue().addIdleHandler(new IdleHandler() {
        @Override
        public boolean queueIdle(long remainingIdleTimeMillis) {
            logNotificationImpression(sbn); // 记录曝光事件
            return false;
        }
    });
}

// 发送即时消息
handler.sendMessage(Message.obtain(handler, 0, "即时消息"));
// 或通过 post 发送 Runnable（本质也是即时消息）
handler.post(() -> textView.setText("更新UI"));

// 延迟 3 秒执行
handler.postDelayed(() -> dialog.dismiss(), 3000);

// Framework 内部使用示例（应用层无法直接调用）
// 1. 发送屏障消息，返回屏障 token
int barrierToken = mQueue.postSyncBarrier();
// 2. 发送异步消息（会穿过屏障）
Message asyncMsg = Message.obtain(handler, () -> performDraw());
asyncMsg.setAsynchronous(true); // 标记为异步消息
handler.sendMessage(asyncMsg);
// 3. 任务完成后移除屏障
mQueue.removeSyncBarrier(barrierToken);

// Framework 源码中的实现（应用层无法直接调用，被 @hide 标记）
public int postSyncBarrier() {
    return postSyncBarrier(SystemClock.uptimeMillis());
}

private int postSyncBarrier(long when) {
    synchronized (this) {
        final int token = mNextBarrierToken++;
        // 创建屏障消息（target = null）
        final Message msg = Message.obtain();
        msg.markInUse();
        msg.when = when;
        msg.arg1 = token; // 存储 token 用于标识屏障

        // 将屏障消息插入消息队列（按 when 时间排序）
        Message prev = null;
        Message p = mMessages;
        if (when != 0) {
            while (p != null && p.when <= when) {
                prev = p;
                p = p.next;
            }
        }
        if (prev != null) {
            msg.next = p;
            prev.next = msg;
        } else {
            msg.next = p;
            mMessages = msg;
        }
        return token; // 返回 token，用于移除屏障
    }
}

// MessageQueue.next() 核心逻辑（简化）
Message next() {
    for (;;) {
        // 阻塞等待消息
        nativePollOnce(ptr, nextPollTimeoutMillis);

        synchronized (this) {
            long now = SystemClock.uptimeMillis();
            Message msg = mMessages;
            
            // 遇到屏障消息（target = null）
            if (msg != null && msg.target == null) {
                // 跳过所有普通消息（target != null），只找异步消息（isAsynchronous() = true）
                do {
                    prevMsg = msg;
                    msg = msg.next;
                } while (msg != null && !msg.isAsynchronous());
            }

            // 找到异步消息或非屏障消息，返回执行
            if (msg != null) {
                return msg;
            }
        }
    }
}

// Framework 源码中的实现
public void removeSyncBarrier(int token) {
    synchronized (this) {
        Message prev = null;
        Message p = mMessages;
        // 遍历队列找到对应的屏障消息（通过 token 匹配）
        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(); // 回收屏障消息
        // 若需要，唤醒阻塞的 Looper
        if (needWake) {
            nativeWake(ptr);
        }
    }
}

// 1. 创建 Handler（主线程或子线程均可）
Handler handler = new Handler(Looper.myLooper()) {
    @Override
    public void handleMessage(@NonNull Message msg) {
        // 处理异步消息
        Log.d("AsyncMessage", "收到异步消息：" + msg.obj);
    }
};

// 2. 创建并标记异步消息
Message asyncMsg = Message.obtain(handler);
asyncMsg.what = 1; // 消息标识
asyncMsg.obj = "我是异步消息";
asyncMsg.setAsynchronous(true); // 关键：标记为异步消息

// 3. 发送消息（支持即时、延迟等发送方式）
handler.sendMessage(asyncMsg);
// 也可发送延迟异步消息
// handler.sendMessageDelayed(asyncMsg, 1000);

// 1. 创建默认发送异步消息的 Handler
Handler asyncHandler = new Handler(Looper.myLooper(), new Handler.Callback() {
    @Override
    public boolean handleMessage(@NonNull Message msg) {
        Log.d("AsyncMessage", "收到默认异步消息：" + msg.obj);
        return true;
    }
}, true); // 第三个参数为 true：该 Handler 发送的消息默认异步

// 2. 直接发送消息（无需手动标记，自动为异步）
Message msg = Message.obtain(asyncHandler);
msg.obj = "默认异步消息";
asyncHandler.sendMessage(msg);

// 创建 HandlerThread，参数为线程名称
HandlerThread handlerThread = new HandlerThread("MyHandlerThread");

handlerThread.start(); // 启动线程，触发内部 Looper 初始化

// 创建子线程 Handler，用于向 HandlerThread 发送消息
Handler workerHandler = new Handler(handlerThread.getLooper()) {
    @Override
    public void handleMessage(@NonNull Message msg) {
        // 此方法在 HandlerThread 的线程中执行
        switch (msg.what) {
            case 1:
                // 处理任务（如网络请求、数据解析）
                String result = processData((String) msg.obj);
                // 如需更新 UI，可通过主线程 Handler 发送结果
                mainHandler.obtainMessage(1, result).sendToTarget();
                break;
            // 其他任务...
        }
    }
};

// 发送消息
Message msg = workerHandler.obtainMessage(1, "任务参数");
workerHandler.sendMessage(msg);

// 或发送 Runnable
workerHandler.post(() -> {
    // 子线程执行的任务
});

// 退出消息循环（必须调用，否则线程不会终止）
handlerThread.quit(); // 或 quitSafely()

public class HandlerThread extends Thread {
    private Looper mLooper;
    private @Nullable Handler mHandler;

    public HandlerThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        mTid = Process.myTid();
        // 1. 初始化 Looper（子线程中）
        Looper.prepare();
        synchronized (this) {
            mLooper = Looper.myLooper();
            notifyAll(); // 唤醒等待 Looper 初始化的线程
        }
        Process.setThreadPriority(mPriority);
        onLooperPrepared(); // 钩子方法，初始化后回调
        // 2. 启动消息循环（阻塞，直到 quit() 被调用）
        Looper.loop();
        mTid = -1;
    }

    // 获取 Looper（若未初始化则阻塞等待）
    public Looper getLooper() {
        if (!isAlive()) {
            return null;
        }
        // 等待 Looper 初始化完成
        synchronized (this) {
            while (isAlive() && mLooper == null) {
                try {
                    wait();
                } catch (InterruptedException e) {
                }
            }
        }
        return mLooper;
    }

    // 退出消息循环（立即终止未处理的消息）
    public boolean quit() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quit();
            return true;
        }
        return false;
    }

    // 安全退出（处理完已入队的消息后终止）
    public boolean quitSafely() {
        Looper looper = getLooper();
        if (looper != null) {
            looper.quitSafely();
            return true;
        }
        return false;
    }
}

// 创建 HandlerThread 用于轮询
HandlerThread pollThread = new HandlerThread("PollThread");
pollThread.start();

// 子线程 Handler
Handler pollHandler = new Handler(pollThread.getLooper()) {
    @Override
    public void handleMessage(@NonNull Message msg) {
        if (msg.what == 1) {
            // 执行轮询任务
            checkNetworkStatus();
            // 延迟 5 秒后再次发送消息（循环执行）
            sendEmptyMessageDelayed(1, 5000);
        }
    }
};

// 启动轮询
pollHandler.sendEmptyMessage(1);

// 共享的 HandlerThread 作为"任务调度中心"
HandlerThread schedulerThread = new HandlerThread("Scheduler");
schedulerThread.start();
Handler schedulerHandler = new Handler(schedulerThread.getLooper()) {
    @Override
    public void handleMessage(@NonNull Message msg) {
        // 所有任务在此线程串行执行，无需加锁
        processTask(msg.obj);
    }
};

// 线程 A 发送任务
new Thread(() -> {
    schedulerHandler.obtainMessage(1, "任务A").sendToTarget();
}).start();

// 线程 B 发送任务
new Thread(() -> {
    schedulerHandler.obtainMessage(1, "任务B").sendToTarget();
}).start();

// 主线程 Handler（用于更新 UI）
Handler mainHandler = new Handler(Looper.getMainLooper()) {
    @Override
    public void handleMessage(@NonNull Message msg) {
        textView.setText((String) msg.obj);
    }
};

// HandlerThread 处理后台任务
HandlerThread bgThread = new HandlerThread("BgThread");
bgThread.start();
Handler bgHandler = new Handler(bgThread.getLooper()) {
    @Override
    public void handleMessage(@NonNull Message msg) {
        // 后台处理
        String result = heavyCompute((String) msg.obj);
        // 发送结果到主线程
        mainHandler.obtainMessage(1, result).sendToTarget();
    }
};

// 启动任务
bgHandler.obtainMessage(1, "计算参数").sendToTarget();