Java中如何获取ExecutorService线程池内活跃/空闲线程的名称或ID

刚好之前做过类似的线程命名需求，给你几个可行的方案，从简单可靠到精准复用ID都有：

如果只是要求线程名称不重复，不需要严格复用空闲ID，这个方案最省心，完全不用担心线程安全和回收问题。用原子变量自增生成唯一ID，即使线程被回收也不会重复使用旧ID：

public class UniqueThreadFactory implements ThreadFactory {
    // 原子变量保证多线程下ID自增的线程安全
    private final AtomicInteger nextThreadId = new AtomicInteger(0);

    @Override
    public Thread newThread(Runnable r) {
        String threadName = "T" + nextThreadId.getAndIncrement();
        Thread thread = new Thread(r, threadName);
        // 根据你的需求调整线程属性，比如是否守护线程、优先级等
        thread.setDaemon(false);
        thread.setPriority(Thread.NORM_PRIORITY);
        return thread;
    }
}

使用的时候直接传入：

ExecutorService service = Executors.newCachedThreadPool(new UniqueThreadFactory());

这个方案的优势是实现极简，没有复杂的状态维护，线程名称绝对唯一，完全符合你“不与当前活跃/空闲线程重名”的要求。

如果一定要像你例子里那样，优先使用回收的ID（比如当前活跃线程是T0、T1、T3，下一个生成T2），可以通过维护已使用ID的集合，每次找最小的未被占用的ID：

import java.util.concurrent.ConcurrentSkipListSet;

public class ReusableThreadFactory implements ThreadFactory {
    // 用有序的并发集合存储已使用的ID，保证线程安全且能快速查找间隙
    private final ConcurrentSkipListSet<Integer> usedIds = new ConcurrentSkipListSet<>();

    @Override
    public Thread newThread(Runnable r) {
        int targetId = 0;
        // 循环找到第一个未被使用的ID
        while (true) {
            if (usedIds.add(targetId)) {
                break;
            }
            // 检查当前ID的下一个可用间隙
            Integer higherId = usedIds.higher(targetId);
            if (higherId == null) {
                // 没有比当前ID更大的已用ID，直接用下一个自增ID
                targetId = usedIds.size();
            } else if (higherId > targetId + 1) {
                // 中间存在间隙，用间隙里的第一个ID
                targetId = targetId + 1;
            } else {
                // 没有间隙，跳到已用ID的下一个
                targetId = higherId + 1;
            }
        }

        String threadName = "T" + targetId;
        Thread thread = new Thread(() -> {
            try {
                // 执行任务
                r.run();
            } finally {
                // 线程结束后，从集合中移除ID，供后续复用
                usedIds.remove(targetId);
            }
        }, threadName);

        thread.setDaemon(false);
        thread.setPriority(Thread.NORM_PRIORITY);
        return thread;
    }
}

这个方案会自动复用已回收线程的ID，生成连续的线程名称，完全匹配你想要的逻辑。需要注意的是，ConcurrentSkipListSet是线程安全的，所以多线程创建线程时也不会出现名称冲突。

如果你只是想临时获取ExecutorService中当前的活跃/空闲线程名称，而不是用于命名逻辑，可以通过反射读取ThreadPoolExecutor的内部workers集合（因为newCachedThreadPool本质是ThreadPoolExecutor的实例）：

ExecutorService service = Executors.newCachedThreadPool();
if (service instanceof ThreadPoolExecutor) {
    ThreadPoolExecutor pool = (ThreadPoolExecutor) service;
    try {
        // 反射获取workers字段（ThreadPoolExecutor的私有字段）
        Field workersField = ThreadPoolExecutor.class.getDeclaredField("workers");
        workersField.setAccessible(true);
        Set<?> workers = (Set<?>) workersField.get(pool);

        // 遍历每个Worker，获取对应的线程
        for (Object worker : workers) {
            Field threadField = worker.getClass().getDeclaredField("thread");
            threadField.setAccessible(true);
            Thread thread = (Thread) threadField.get(worker);
            System.out.println("当前线程名称：" + thread.getName());
        }
    } catch (NoSuchFieldException | IllegalAccessException e) {
        e.printStackTrace();
    }
}

注意：这个方案依赖JDK的内部实现，不同版本的JDK可能会修改ThreadPoolExecutor的私有字段结构，所以绝对不推荐在生产环境使用，仅适合临时调试。

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