Threads configuration based on no. of CPU-cores

by

The optimal number of threads to use depends on several factors, but mostly the number of available processors and how cpu-intensive your tasks are. Java Concurrency in Practice proposes the following formal formula to estimate the optimal number of threads:

N_threads = N_cpu * U_cpu * (1 + W / C)

Where:

  • N_threads is the optimal number of threads
  • N_cpu is the number of prcessors, which you can obtain from Runtime.getRuntime().availableProcessors();
  • U_cpu is the target CPU utilization (1 if you want to use the full available resources)
  • W / C is the ratio of wait time to compute time (0 for CPU-bound task, maybe 10 or 100 for slow I/O tasks)

So for example, in a CPU-bound scenario, you would have as many threads as CPU (some advocate to use that number + 1 but I have never seen that it made a significant difference).

For a slow I/O process, for example a web crawler, W/C could be 10 if downloading a page is 10 times slower than processing it, in which case using 100 threads would be useful.

Note however that there is an upper bound in practice (using 10,000 threads will generally not speed things up, and you would probably get an OutOfMemoryError before you can start them all anyway with normal memory settings).

This is probably the best estimate you can get if you don’t know anything about the environment in which your application runs. Profiling your application in production might enable you to fine tune the settings.

Although not strictly related, you might also be interested in Amdahl’s law, which aims at measuring the maximum speed-up you can expect from parallelising a program.

More Related Contents:

  1. ExecutorService, how to wait for all tasks to finish
  2. Turning an ExecutorService to daemon in Java
  3. How are Threads allocated to handle Servlet request?
  4. AsyncTask.executeOnExecutor() before API Level 11
  5. FixedThreadPool vs CachedThreadPool: the lesser of two evils
  6. How Threadpool re-use Threads and how it works
  7. Propagating ThreadLocal to a new Thread fetched from a ExecutorService
  8. Removing all queued tasks of an ThreadPoolExecutor
  9. Dynamic Thread Pool
  10. JAVAFX : why wait cursor needs a new thread?
  11. Using threads to make database requests
  12. Why is spawning threads in Java EE container discouraged?
  13. wait until all threads finish their work in java
  14. When would you call java’s thread.run() instead of thread.start()?
  15. Updating UI from different threads in JavaFX
  16. How to get the ThreadPoolExecutor to increase threads to max before queueing?
  17. How does memory reordering help processors and compilers?
  18. Refreshing GUI by another thread in java (swing)
  19. Printing Even and Odd using two Threads in Java
  20. How does Java makes use of multiple cores?
  21. How does `this` reference to an outer class escape through publishing inner class instance?
  22. How do I prove programmatically that StringBuilder is not threadsafe?
  23. When does a Java Thread reach the ‘Die’ State
  24. What determines the number of threads a Java ForkJoinPool creates?
  25. How does the JVM terminate daemon threads? or How to write daemon threads that terminate gracefully
  26. Run Handler messages in a background thread
  27. Regarding thread safety of servlet [duplicate]
  28. who and when notify the thread.wait() when thread.join() is called?
  29. Will a chain of method calls (CompletableFuture API) execute asynchronously if the first method in a chain is asynchronous?
  30. Concurrent read/write of named pipe in Java (on windows)

Leave a Comment