Java中如何实现多个Thread线程同时启动，替代for循环逐个启动的方案

核心原理 #

for循环逐个调用start()确实存在微小的时间差，无法让所有线程的业务执行逻辑同时启动，因为CPU执行循环指令、线程的启动调度都需要时间。目前Java层面没有办法做到100%绝对的同时启动，但可以通过同步工具类把业务逻辑启动的时间差压缩到毫秒甚至纳秒级，满足几乎所有业务场景的「同时启动」需求。

方案1：使用CountDownLatch实现统一发令 #

这是最常用的实现方案，逻辑是让所有启动后的线程先阻塞等待发令信号，主线程完成所有线程的启动操作后再统一放行，代码示例如下：

import java.util.concurrent.CountDownLatch;

// 自定义线程类
class MyThread extends Thread {
    private final CountDownLatch startLatch;
    
    public MyThread(CountDownLatch startLatch) {
        this.startLatch = startLatch;
    }
    
    @Override
    public void run() {
        try {
            // 所有线程启动后先阻塞，等待发令
            startLatch.await();
            // 这里放你的业务逻辑，所有线程会几乎同时执行到这里
            // doSomething();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException(e);
        }
    }
}

// 调用逻辑
public class Main {
    public static void main(String[] args) throws InterruptedException {
        int k = 10; // 你的用户输入参数k
        CountDownLatch startLatch = new CountDownLatch(1);
        MyThread[] threads = new MyThread[k];
        
        // 先初始化所有线程
        for (int i = 0; i < k; i++) {
            threads[i] = new MyThread(startLatch);
        }
        
        // 逐个启动线程，此时线程启动后会阻塞在await()
        for (MyThread thread : threads) {
            thread.start();
        }
        
        // 主线程发令，所有线程同时唤醒执行业务逻辑
        startLatch.countDown();
        
        // 如果需要等待所有线程执行完成，可以再加一个结束的CountDownLatch
    }
}

方案2：使用线程池优化线程管理 #

如果你的参数k可能很大（比如超过几十），直接创建大量原生线程会浪费系统资源，更优的方案是使用线程池来管理线程，同样可以配合CountDownLatch实现同时启动：

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        int k = 10;
        CountDownLatch startLatch = new CountDownLatch(1);
        // 固定大小线程池，也可以根据业务场景选择其他线程池实现
        ExecutorService executor = Executors.newFixedThreadPool(k);
        
        // 提交所有任务
        for (int i = 0; i < k; i++) {
            executor.submit(() -> {
                try {
                    startLatch.await();
                    // 业务逻辑
                    // doSomething();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }
        
        // 统一发令
        startLatch.countDown();
        // 用完关闭线程池
        executor.shutdown();
    }
}

注意事项 #

• 上述方案只能保证Java应用层面的业务逻辑尽可能同时启动，操作系统内核的线程调度仍然存在微秒级的时间差，不会影响正常业务使用。
• 如果你的场景对启动同步精度要求极高，可以在startLatch.await()之后再增加一个自旋等待的逻辑，进一步缩小时间差。

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