Set available processors in Executors.newFixedThreadPool in HTTPServer

I'm building an HTTPServer that needs to handle multiple requests at the same time.

The main function of what I built looks like this:

public static void main(String[] args) throws Exception {
    HttpServer server = HttpServer.create(new InetSocketAddress(8000), 0);
    server.createContext("/", new MyRequestDispatcher());

    server.setExecutor(Executors.newCachedThreadPool());
    server.start();
}

Now I'm thinking on how this Executors.newCachedThreadPool() works regarding the number of threads created. As I have read that the number of threads to be created is not limited, if I get a thousand of requests at the same time, would it create a thousand of threads?

I'm thinking on limiting the number of threads created at the same time in order to be handled properly in the machine where it is being run. I thought on something like this:

Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors())

The goal is to only create the given number of threads depending on the available processors in the system.

Would this work?

Thanks in advance!!

Yes, it will work, and it's what you'll see recommended most often.

Depending on your specific use-case you still may want to use a different number.

• If your tasks are blocking (e.g. because of I/O operations), you may benefit from more threads than available cores.
• If you can run multiple hardware threads per core, you may also benefit from more threads than available cores. For example, Intel x86 Xeons with Hyperthreading enabled can run 2 threads per core, IBM POWER8 and Oracle SPARC M7 - up to 8 threads per core.
• If you are running concurrent GC collectors, you experience significant GC pressure, and you have a non-stop running thread pool, you may find that slightly decreasing the number of threads in the pool can move you in a sweeter spot. This is a fairly specific example, though, which I'm mentioning because it was a big revelation in the system I'm currently working on.