如何实现主线程等待子线程启动后通知其停止？现有方案是否可行？

当前实现的正确性分析 #

你的核心思路是对的：用CountDownLatch runningTrigger让主线程等待Worker线程启动完成，用stopTrigger通知Worker线程停止。但代码存在几个语法/拼写错误，会导致无法正常运行：

• Worker类里的CoutnDownLatch、CountdownLatch是拼写错误，正确应为CountDownLatch
• Runnable接口的run()方法必须是public修饰，你写的void run()缺少public修饰符
• 捕获的Interrupted ...应为InterruptedException，且直接忽略中断信号不是合理做法，会导致线程无法响应后续中断请求

修正这些错误后，核心逻辑可以运行，但存在局限性：

• CountDownLatch是一次性组件，countDown()后无法重置，Worker线程只能被使用一次，无法复用
• 忽略InterruptedException会掩盖中断信号，可能导致线程在某些场景下无法及时停止

更优实现方案 #

方案1：线程中断机制（推荐） #

Java的线程中断是协作式停止线程的标准方式，比CountDownLatch更灵活，符合线程模型设计规范。

测试代码：

Thread t = new Thread(new Worker());
t.start();
// 等待线程启动（用join设置超时避免无限等待，或用CountDownLatch做精确启动通知）
t.join(1000);
// 执行验证操作
t.interrupt(); // 通知线程停止

Worker类实现：

class Worker implements Runnable {
    @Override
    public void run() {
        try {
            // 模拟业务逻辑，通过中断状态控制循环
            while (!Thread.currentThread().isInterrupted()) {
                // 执行任务逻辑
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            // 重置中断状态，让上层逻辑能感知到中断
            Thread.currentThread().interrupt();
            System.out.println("线程收到停止信号，准备退出");
        }
    }
}

如果需要精确校验线程启动状态，可以结合CountDownLatch和中断机制：

CountDownLatch runningTrigger = new CountDownLatch(1);
Thread t = new Thread(new Worker(runningTrigger));
t.start();
runningTrigger.await(); // 等待线程明确启动
// 执行验证操作
t.interrupt();

class Worker implements Runnable {
    private final CountDownLatch runningTrigger;

    public Worker(CountDownLatch runningTrigger) {
        this.runningTrigger = runningTrigger;
    }

    @Override
    public void run() {
        runningTrigger.countDown(); // 通知主线程已启动
        try {
            while (!Thread.currentThread().isInterrupted()) {
                // 业务逻辑
                Thread.sleep(100);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.out.println("线程停止");
        }
    }
}

方案2：volatile变量控制停止 #

如果不想用中断机制，可用volatile修饰的布尔变量控制线程运行状态，适合简单场景：

测试代码：

Worker worker = new Worker();
Thread t = new Thread(worker);
t.start();
// 等待线程启动
worker.waitForStart();
// 执行验证操作
worker.stop();

Worker类实现：

class Worker implements Runnable {
    private volatile boolean running = true;
    private final CountDownLatch runningTrigger = new CountDownLatch(1);

    @Override
    public void run() {
        runningTrigger.countDown();
        while (running) {
            // 业务逻辑
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                break;
            }
        }
    }

    public void waitForStart() {
        try {
            runningTrigger.await();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    public void stop() {
        running = false;
    }
}

方案3：ExecutorService管理线程 #

生产环境推荐用ExecutorService管理线程，它提供了更完善的生命周期控制：

ExecutorService executor = Executors.newSingleThreadExecutor();
CountDownLatch runningTrigger = new CountDownLatch(1);
Future<?> future = executor.submit(new Worker(runningTrigger));
runningTrigger.await();
// 执行验证操作
future.cancel(true); // 取消任务，true表示中断线程
executor.shutdown();

总结 #

• 原实现思路正确，但存在语法错误和复用性问题
• 优先推荐线程中断机制，它是Java标准的协作式线程停止方式，灵活且规范
• 简单场景可用volatile变量控制，生产环境建议用ExecutorService管理线程生命周期

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