Java8固定线程池是否总是创建固定数量的线程？

我正在看Java8固定线程池的代码。以下是一个小样本：

    ExecutorService service = Executors.newFixedThreadPool(100);

    try {

        for (int i = 0; i < 10; ++i) {
            service.submit(() -> "In another thread!");
        }

    } catch (Exception e) {
        // Do nothing
    } finally {
        service.shutdown();
    }

ExecutorService=Executors.newFixedThreadPool（100）；
试一试{
对于（int i=0；i<10；++i）{
提交（（）->“在另一个线程中！”）；
}
}捕获（例外e）{
//无所事事
}最后{
service.shutdown（）；
}

我的问题是（分两部分）：

a。上面的固定线程池对象将创建多少线程？100? 还是只有10个

b。如何检查已创建的线程数

上面的固定线程池对象将创建多少线程？100? 还是只有10个

它没有指定。所规定的是永远不会超过100个

如何检查已创建的线程数

---

这方面没有API。您可以得到前后的总线程数，但这可能是模糊的，因为Java还有其他创建线程的原因。

以下是两个简单的类，我在学习

ExecutorService

、

Callable

和

Future

类时使用它们作为习惯用法

您可以看到，我使用了一个大小为2的线程池，并且有10项需要处理。基本上，您可以创建一个线程池，传入实现

可调用的类

，并使用生成的

未来

作为处理的证明。给定大小为2的线程池，一次只能处理两个项目。如果希望看到结果，可以更改这些值

Main.java：

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Main {

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(2);

        List<Future<String>> lst = new ArrayList<Future<String>>();

        for (int i = 0; i < 10; ++i) {
            Callable<String> callable = new Calling();
            Future<String> future = executorService.submit(callable);
            lst.add(future);
        }

        int futureCount = 0;
        for (Future<String> fut : lst) {
            try {
                futureCount++;
                System.out.println("Processed call() in thread " + fut.get() + ", future number: " + futureCount);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        executorService.shutdown();
        while (!executorService.isTerminated()) {
            // wait, basically
        }

        System.out.println("Finished all threads!");

    }
}

import java.util.ArrayList；
导入java.util.List；
导入java.util.concurrent.Callable；
导入java.util.concurrent.ExecutorService；
导入java.util.concurrent.Executors；
导入java.util.concurrent.Future；
公共班机{
公共静态void main（字符串[]args）{
ExecutorService ExecutorService=Executors.newFixedThreadPool（2）；
List lst=new ArrayList（）；
对于（int i=0；i<10；++i）{
Callable Callable=新调用（）；
Future=executorService.submit（可调用）；
第一次增补（未来）；
}
int futurecont=0；
用于（未来未来未来：lst）{
试一试{
futureCount++；
System.out.println（“线程中的已处理调用（）+fut.get（）+”，未来编号：“+futureCount”）；
}捕获（例外e）{
e、 printStackTrace（）；
}
}
executorService.shutdown（）；
而（！executorService.isTerminated（））{
//等等，基本上
}
System.out.println（“完成所有线程！”）；
}
}

调用.java

import java.util.concurrent.Callable;

public class Calling implements Callable<String> {

    public Calling() {
    }

    public String call() throws InterruptedException {
        System.out.println("Sleeping thread: " + Thread.currentThread().getName());
        Thread.sleep(2000);
        return Thread.currentThread().getName();
    }

}

import java.util.concurrent.Callable；
公共类调用实现了可调用{
公共电话（）{
}
公共字符串调用（）引发InterruptedException{
System.out.println（“休眠线程：+thread.currentThread（）.getName（））；
《睡眠》（2000年）；
返回Thread.currentThread（）.getName（）；
}
}

请不要假设执行者将如何在应用程序代码中启动底层线程。为了满足你的好奇心：

上面的固定线程池对象将创建多少线程？100? 还是只有10个

完全取决于使用的

ThreadFactory

——默认情况下，固定线程池会延迟生成线程。当然，除非另有说明，否则这可能会在任何后续JDK中发生变化。正如@EJP所说，您可以依赖的唯一不变量是它们不会超过100个

如何检查已创建的线程数

---

无法获取专用于特定执行器的线程，但是可以从JVM内部获取所有活动线程的调用堆栈映射。或者使用VisualVM之类的工具。

如果你要否决我的答案，请解释原因。我看不出为什么我的回答没有提供有价值的背景来帮助教育OP。谢谢！看来我的问题已经被回答了。