Java Executor Service 在应用程序启动时启动线程

Question

When my application launches, a executor service (using Executors.newFixedThreadPool(maxThreadNum) in java.util.concurrent) object is created. When requests come, the executor service will creates threads to handle them.

Because it takes time to create threads at run time, I want to make threads available when launching application, so that when requests come, it would take less time to process.

What I did is following:

executorService = Executors.newFixedThreadPool(200);
for (int i=0; i<200; i++) {
    executorService.execute(new Runnable() {
        @Override
        public void run() {
            System.out.println("Start thread in pool " );
        }
    });
}

It will creates 200 threads in the executorService pool when application launches.

Just wonder is this a correct way of creating threads when application starts? Or is there a better way of doing it?

Answer 1

You are missing shutdown() .It is very important to shutdown the Executor service once the operation is completed. So have try,catch and Finally block

try{ executorService.execute(...); }catach(Exception e){ ... }finally{ executorService.shutdown(); //Mandatory }

Answer 2

If you can use a ThreadPoolExecutor directly rather than an ExecutorService from Executors ¹ , then there's perhaps a more standard/supported way to start all the core threads immediately.

int nThreads = 200;
ThreadPoolExecutor executor = new ThreadPoolExecutor(nThreads, nThreads, 
        0L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>());
executor.prestartAllCoreThreads();

The above uses prestartAllCoreThreads() .

Note that, currently, the implementation of Executors.newFixedThreadPool(int) creates a ThreadPoolExecutor in the exact same manner as above. This means you could technically cast the ExecutorService returned by the factory method to a ThreadPoolExecutor . There's nothing in the documentation that guarantees it will be a ThreadPoolExecutor , however.

---

^{1. ThreadPoolExecutor implements ExecutorService but provides more functionality. Also, many of the factory methods in Executors either returns a ThreadPoolExecutor directly or a wrapper that delegates to one. Some, like newWorkStealingPool , use the ForkJoinPool . Again, the return types of these factory methods are implementation details so don't rely too much on it.}

Answer 3

The number of threads which could run parallel depends on your processor core. Unless you have 200 cores it would be pretty useless to make a thread pool of 200.

A great way to find out how many processors cores you have is:

int cores = Runtime.getRuntime().availableProcessors();

Moreover the overhead which develops during creating a new thread and executing it is unavoidable, so unless the task is heavily computed it would not be worth to create a new single thread for this task.

But after all your code is total fine so far.

Answer 4

Your code is totally fine if it works for your scenario. Since we don't know your use case, only you can answer your question with enough tests and benchmark.

However, do take note that the ThreadPool will reclaim idle threads after some time. That may bite you if you don't pay attention to it.

Answer 5

Just wonder is this a correct way of creating threads when application starts?

Yes. That's a correct way of creating threads.

Or is there a better way of doing it?

Maybe. Under some workloads you might want to use a Thread pool with a variable number of threads (unlike the one created by newFixedThreadPool ) - one that removes from the pool threads that have been idle for some time.