executorservice

I am using the Executors framework in Java to create thread pools for a multi-threaded application, and I have a question related to performance. I have an application which can work in realtime or non-realtime mode. In case it's realtime, I'm simply using the following: THREAD_POOL = Executors.newCachedThreadPool(); But in case it's not realtime, I want the ability to control the size of my thread pool. To do this, I'm thinking about 2 options, but I don't really understand the difference, and which one would perform better. Option 1 is to use the simple way: THREAD_POOL = Executors

I am pretty new to multithreading, and I am working on a project where I am trying to utilize 4 CPUs in my Java program. I wanted to do something like int numProcessors = Runtime.getRuntime().availableProcessors(); ExecutorService e = Executors.newFixedThreadPool(numProcessors); Will this guarantee that I will have one thread working per CPU? At the time that I create the threads, the system will not be busy, however some time afterwards it will be extremely busy. I thought that the OS will pick the least busy CPU to create the threads, but how does it work if none of them are particularly

I'm figuring what a timer implementation to use if you need to schedule tons of (non blocking) tasks as fast as possible inside jvm on one machine. I've studied ScheduledThreadPoolExecutor and HashedWheelTimer sources (+wheel timer general docs) and here are basic differences (N - number of all outstanding scheduled tasks so far, C - wheel size): ScheduledThreadPoolExecutor O(log N) for adding new task O(1) per each timer tick (but tick per each task, so N overall) O(log N) cancelling the task lock per each tick/task HashedWheelTimer O(1) adding new task O(m) per each timer tick (m ~ N/C where

I put a bunch of runnable objects into an ExecutorService: // simplified content of main method ExecutorService threadPool = Executors.newCachedThreadPool(); for(int i = 0; i < workerCount; i++) { threadPool.execute(new Worker()); } I would expect my program/process to stop immediately after all workers are done. But according to my log, it takes another 20-30 seconds until that happens. The workers do not allocate any resources, in fact, they do nothing at the moment. Don't get me wrong, this is not a crucial problem for me, I'm just trying to understand what is happening and I'm wondering if

CompletableFuture::supplyAsync(() -> IO bound queries) How do I chose an Executor for CompletableFuture::supplyAsync to avoid polluting the ForkJoinPool.commonPool() . There are many options in Executors ( newCachedThreadPool , newWorkStealingPool , newFixedThreadPool etc) And I read about new ForkJoinPool here How do I chose the right one for my use case ? You should use public static <U> CompletableFuture<U> supplyAsync(Supplier<U> supplier, Executor executor) method. As executor you can use any from the Executors.new.. - it depends on your needs. It's better to use newFixedThreadPool()

This question already has an answer here: Naming threads and thread-pools of ExecutorService 17 answers I have a Java application that uses the Executor framework and I have code that looks like this protected ScheduledExecutorService scheduledExecutorService = new ScheduledThreadPoolExecutor(5) My understanding is that internally the JVM would create a pool of 5 threads. Now when I check the execution in a profiler, I get something like thread-pool2,thread-pool3 and so on. Some of these thread pools are created by the server and some are created by me , I need a way to differentiate which