如何从内部任务停止ScheduledThreadPoolExecutor并实现线程间通知？

咱们先把核心问题理清楚：线程池里的周期性任务线程和你的Buyer线程是完全独立的执行流，没法直接“唤醒”父线程，得靠Java的线程间通信机制来实现。下面是几个落地性强的方案，你可以根据业务场景选：

方案一：给任务传递Buyer的回调接口 #

最直观的方式是定义一个回调接口，让Buyer实现它，再把Buyer实例传给周期性任务。当任务触发停止条件时，直接调用回调方法通知Buyer，由Buyer统一处理线程池停止和MasterContainer的通知逻辑。

示例代码如下：

// 定义回调接口，约定通知行为
interface TaskStopCallback {
    void onTaskTriggerStop();
}

// Buyer类实现回调，同时作为线程执行体
class Buyer implements Runnable, TaskStopCallback {
    private ScheduledThreadPoolExecutor executor;

    @Override
    public void run() {
        // 初始化线程池
        executor = new ScheduledThreadPoolExecutor(1);
        // 把自身作为回调传给任务
        executor.scheduleAtFixedRate(new PeriodicTask(this), 0, 1, TimeUnit.SECONDS);
        
        // 这里可以处理Buyer线程的其他逻辑，或者配合锁/阻塞工具等待回调触发
    }

    @Override
    public void onTaskTriggerStop() {
        // 优雅停止线程池
        executor.shutdown();
        // 向MasterContainer发送通知（比如用共享队列、锁或者直接调用Master的线程安全方法）
        notifyMasterContainer();
    }

    private void notifyMasterContainer() {
        // 实现你的通知逻辑，比如往Master的消息队列里放信号
    }
}

// 周期性任务类，持有回调引用
class PeriodicTask implements Runnable {
    private TaskStopCallback callback;

    public PeriodicTask(TaskStopCallback callback) {
        this.callback = callback;
    }

    @Override
    public void run() {
        // 检查触发停止的特定条件
        if (shouldStopTask()) {
            // 通知Buyer线程
            callback.onTaskTriggerStop();
            // 取消后续任务调度
            ((ScheduledFuture<?>) Thread.currentThread()).cancel(false);
        }
        // 正常执行任务逻辑
    }

    private boolean shouldStopTask() {
        // 你的条件判断逻辑，比如某个业务状态达标
        return false;
    }
}

这个方案的优势是响应及时，任务触发条件后立刻通知Buyer。注意如果多个任务可能同时触发回调，要确保回调方法是线程安全的（比如加synchronized或者用原子类）。

方案二：用同步工具类（CountDownLatch）实现阻塞等待 #

如果你的场景是任务只会触发一次停止条件，CountDownLatch是个不错的选择。在Buyer线程里初始化一个计数为1的Latch，传给任务；任务触发条件时调用countDown()，Buyer线程在await()上阻塞等待，一旦Latch计数归0，就执行后续逻辑。

示例代码：

class Buyer implements Runnable {
    private ScheduledThreadPoolExecutor executor;

    @Override
    public void run() {
        CountDownLatch stopSignal = new CountDownLatch(1);
        executor = new ScheduledThreadPoolExecutor(1);
        executor.scheduleAtFixedRate(new PeriodicTask(stopSignal), 0, 1, TimeUnit.SECONDS);
        
        try {
            // 阻塞等待任务的停止信号
            stopSignal.await();
            // 停止线程池
            executor.shutdown();
            // 通知MasterContainer
            notifyMasterContainer();
        } catch (InterruptedException e) {
            // 处理中断，比如强制停止线程池
            executor.shutdownNow();
            Thread.currentThread().interrupt();
        }
    }

    // ... notifyMasterContainer方法同上
}

class PeriodicTask implements Runnable {
    private CountDownLatch stopSignal;

    public PeriodicTask(CountDownLatch stopSignal) {
        this.stopSignal = stopSignal;
    }

    @Override
    public void run() {
        if (shouldStopTask()) {
            // 触发信号，唤醒Buyer线程
            stopSignal.countDown();
            // 取消后续调度
            ((ScheduledFuture<?>) Thread.currentThread()).cancel(false);
        }
        // 任务逻辑
    }

    // ... shouldStopTask方法同上
}

这个方案适合一次性触发的场景，Buyer线程不用轮询，资源消耗低。如果需要多次触发通知，可以换成CyclicBarrier（可重置的同步工具）。

方案三：用volatile共享状态+Buyer线程轮询 #

如果业务逻辑允许一定的延迟，可以用一个volatile修饰的布尔变量来传递状态。任务触发条件时修改这个变量，Buyer线程定期轮询变量状态，一旦检测到状态变化，就执行停止和通知逻辑。

示例代码：

class Buyer implements Runnable {
    private ScheduledThreadPoolExecutor executor;
    // volatile保证线程间的可见性
    private volatile boolean taskTriggeredStop = false;

    @Override
    public void run() {
        executor = new ScheduledThreadPoolExecutor(1);
        executor.scheduleAtFixedRate(new PeriodicTask(this), 0, 1, TimeUnit.SECONDS);
        
        // 轮询检查状态
        while (!taskTriggeredStop) {
            try {
                Thread.sleep(500); // 调整轮询间隔，平衡延迟和资源消耗
            } catch (InterruptedException e) {
                executor.shutdownNow();
                Thread.currentThread().interrupt();
                break;
            }
        }
        
        executor.shutdown();
        notifyMasterContainer();
    }

    public void setTaskTriggeredStop(boolean triggered) {
        this.taskTriggeredStop = triggered;
    }

    // ... notifyMasterContainer方法同上
}

class PeriodicTask implements Runnable {
    private Buyer buyer;

    public PeriodicTask(Buyer buyer) {
        this.buyer = buyer;
    }

    @Override
    public void run() {
        if (shouldStopTask()) {
            buyer.setTaskTriggeredStop(true);
            ((ScheduledFuture<?>) Thread.currentThread()).cancel(false);
        }
        // 任务逻辑
    }

    // ... shouldStopTask方法同上
}

这个方案实现简单，但轮询会消耗少量CPU资源，适合对延迟要求不高的场景。

关键注意事项 #

• 停止线程池时优先用shutdown()（优雅停止），如果需要立即终止用shutdownNow()，但要注意处理任务的中断逻辑。
• 所有跨线程共享的变量，要么用volatile保证可见性，要么加锁确保线程安全。
• 向MasterContainer发送通知时，同样要遵循线程间通信规则，比如用阻塞队列传递消息，或者调用Master的线程安全方法。

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