Java 11如何在线程完成当前任务后安全锁定目标线程

你的场景属于典型的协作式线程暂停需求，核心要求是暂停动作只在Loader线程的任务间隙（安全点）生效，绝对不能打断正在执行的资源密集型任务，原Semaphore方案除了你提到的两个问题，还存在普通布尔变量多线程可见性缺失、Semaphore许可计数易被打乱的隐藏缺陷。

推荐实现：基于LockSupport的完全封装方案 #

这个方案把所有同步逻辑完全封装在Loader线程内部，对外只暴露语义化操作接口，不泄露任何底层同步原语，从根源上避免外部误操作导致的线程永久挂起问题。

import java.util.concurrent.locks.LockSupport;

public class DataLoaderThread extends Thread {
    // 多线程共享状态必须加volatile保证可见性
    private volatile boolean pauseRequested = false;
    private volatile boolean paused = false;
    private volatile Thread loaderThread;

    @Override
    public void run() {
        loaderThread = this;
        while (true) {
            // 每轮循环起始为安全点，检查暂停请求
            if (pauseRequested) {
                paused = true;
                // 循环检查标记，避免虚假唤醒
                while (pauseRequested) {
                    LockSupport.park();
                }
                paused = false;
            }

            // ------------------------------
            // 以下为实际数据加载、预处理逻辑
            // 这部分执行全程不会被打断
            processBatchData();
            // ------------------------------
        }
    }

    /**
     * 对外仅暴露请求暂停接口，无底层同步原语泄露
     * 调用后Loader不会立刻暂停，会在当前任务执行完成后停在安全点
     */
    public void requestPause() {
        pauseRequested = true;
    }

    /**
     * 对外仅暴露恢复接口，无权限操作底层挂起/唤醒逻辑
     */
    public void requestResume() {
        pauseRequested = false;
        LockSupport.unpark(loaderThread);
    }

    /**
     * 供主线程检查Loader是否已经完全停稳
     */
    public boolean isPaused() {
        return paused;
    }

    private void processBatchData() {
        // 实际业务逻辑：大批量数据加载、资源预处理
    }
}

方案优势 #

• 彻底解决你提到的两个痛点：
  • 所有同步原语（LockSupport相关操作）完全私有，外部代码没有权限直接操作挂起/唤醒逻辑，不存在暴露Semaphore释放权限的问题
  • LockSupport的unpark操作采用单许可模式，重复调用也不会出现许可计数混乱，就算resume调用早于pause触发，Loader也不会永久挂起
• 额外可靠性保障：
  • 所有共享状态用volatile修饰，彻底解决多线程下的状态可见性问题
  • 暂停检查只在循环起始的安全点触发，100%保证不会在数据处理中途打断任务
  • 采用循环检查暂停标记的方式处理挂起，完全规避虚假唤醒导致的意外恢复

主线程正确调用流程 #

调用暂停方法后不要直接执行后续逻辑，必须等待Loader确认已经停在安全点再操作，Java 11可直接用Thread.onSpinWait()优化自旋等待性能：

// 发起暂停请求
dataLoader.requestPause();
// 等待Loader完全停稳
while (!dataLoader.isPaused()) {
    Thread.onSpinWait();
}
// 此处可安全执行需要Loader暂停的操作
// ... 你的业务逻辑 ...
// 操作完成后恢复Loader运行
dataLoader.requestResume();

备选：封装版Semaphore实现 #

如果你偏好原方案的Semaphore逻辑，也可以通过完全封装规避原方案的问题，注意Semaphore必须设为私有，禁止对外暴露：

import java.util.concurrent.Semaphore;

public class SemaphoreLoaderThread extends Thread {
    private volatile boolean pauseRequested = false;
    private volatile boolean paused = false;
    // Semaphore完全私有，外部无任何访问权限
    private final Semaphore pauseSemaphore = new Semaphore(1, true);

    @Override
    public void run() {
        while (true) {
            if (pauseRequested) {
                paused = true;
                pauseSemaphore.acquireUninterruptibly();
                paused = false;
            }
            processBatchData();
        }
    }

    public void requestPause() {
        pauseRequested = true;
        // 主线程提前占用许可，Loader走到安全点时会自动阻塞
        pauseSemaphore.acquireUninterruptibly();
    }

    public void requestResume() {
        pauseRequested = false;
        pauseSemaphore.release();
    }

    public boolean isPaused() {
        return paused;
    }

    private void processBatchData() {}
}

注意：这个Semaphore版本要求requestPause()和requestResume()必须严格成对调用，否则会出现许可计数错乱，容错性低于LockSupport版本，优先推荐前一种实现。

内容的提问来源于stack exchange，提问作者Aisaax