Executors.newCachedThreadPool() versus Executors.newFixedThreadPool()

by

I think the docs explain the difference and usage of these two functions pretty well:

newFixedThreadPool

Creates a thread pool that reuses a
fixed number of threads operating off
a shared unbounded queue. At any
point, at most nThreads threads will
be active processing tasks. If
additional tasks are submitted when
all threads are active, they will wait
in the queue until a thread is
available. If any thread terminates
due to a failure during execution
prior to shutdown, a new one will take
its place if needed to execute
subsequent tasks. The threads in the
pool will exist until it is explicitly
shutdown.

newCachedThreadPool

Creates a thread pool that creates new
threads as needed, but will reuse
previously constructed threads when
they are available. These pools will
typically improve the performance of
programs that execute many short-lived
asynchronous tasks. Calls to execute
will reuse previously constructed
threads if available. If no existing
thread is available, a new thread will
be created and added to the pool.
Threads that have not been used for
sixty seconds are terminated and
removed from the cache. Thus, a pool
that remains idle for long enough will
not consume any resources. Note that
pools with similar properties but
different details (for example,
timeout parameters) may be created
using ThreadPoolExecutor constructors.

In terms of resources, the newFixedThreadPool will keep all the threads running until they are explicitly terminated. In the newCachedThreadPool Threads that have not been used for sixty seconds are terminated and removed from the cache.

Given this, the resource consumption will depend very much in the situation. For instance, If you have a huge number of long running tasks I would suggest the FixedThreadPool. As for the CachedThreadPool, the docs say that “These pools will typically improve the performance of programs that execute many short-lived asynchronous tasks”.

More Related Contents:

  1. Impossible to make a cached thread pool with a size limit?
  2. How to wait for all threads to finish, using ExecutorService?
  3. ExecutorService that interrupts tasks after a timeout
  4. Handling exceptions from Java ExecutorService tasks
  5. How to properly use Java Executor?
  6. What are the advantages of using an ExecutorService?
  7. Java’s Fork/Join vs ExecutorService – when to use which?
  8. ThreadPoolExecutor Block When Queue Is Full?
  9. Java ExecutorService: awaitTermination of all recursively created tasks
  10. ThreadPoolExecutor Block When its Queue Is Full?
  11. How to pause/resume all threads in an ExecutorService in Java?
  12. Handling Exceptions for ThreadPoolExecutor
  13. Dynamic Thread Pool
  14. ExecutorCompletionService? Why do need one if we have invokeAll?
  15. What’s the difference between Thread start() and Runnable run()
  16. Choose between ExecutorService’s submit and ExecutorService’s execute
  17. How to get the ThreadPoolExecutor to increase threads to max before queueing?
  18. What are the main uses of yield(), and how does it differ from join() and interrupt()?
  19. Is ExecutorService (specifically ThreadPoolExecutor) thread safe?
  20. When should I use a CompletionService over an ExecutorService?
  21. Forcing multiple threads to use multiple CPUs when they are available
  22. How to use invokeAll() to let all thread pool do their task?
  23. Why does Java not see the updated value from another thread?
  24. What is adaptive spinning w.r.t lock acquisition?
  25. How to shutdown an ExecutorService?
  26. Thread Confinement
  27. How can I wrap a method so that I can kill its execution if it exceeds a specified timeout?
  28. ExecutorService vs Casual Thread Spawner
  29. notifyAll() throws IllegalMonitorStateException
  30. Will a chain of method calls (CompletableFuture API) execute asynchronously if the first method in a chain is asynchronous?

Leave a Comment