Detailed difference between Java8 ForkJoinPool and

问题:

What is the low-level difference among using:

ForkJoinPool = new ForkJoinPool(X);

and

ExecutorService ex = Executors.neWorkStealingPool(X);

Where X is the desired level of parallelism i.e threads running..

According to the docs I found them similar. Also tell me which one is more appropriate and safe under any normal uses. I have 130 million entries to write into a BufferedWriter and Sort them using Unix sort by 1st column.

Also let me know how many threads to keep if possible.

Note: My System has 8 core processors and 32 GB RAM.

回答1:

Work stealing is a technique used by modern thread-pools in order to decrease contention on the work queue.

A classical threadpool has one queue, and each thread-pool-thread locks the queue, dequeue a task and then unlocks the queue. if the tasks are short and there are many of them, there is a lot of contention on the queue. using a lock-free queue really helps here, but doesn't solve the problem entirely.

Modern thread pools use work stealing - each thread has its own queue. when a threadpool thread produces a task - it enqueues it to his own queue. when a threadpool thread wants to dequeue a task - it first tries to dequeue a task out of his own queue and if it doesn't have any - it "steals" work from other thread queues. this really decreases the contention of the theradpool and improve performance.

newWorkStealingPool creates a workstealing-utilizing thread pool with the number of threads as the number of processors.

newWorkStealingPool presents a new problem. if I have four logical cores, then the pool will have four threads total. if my tasks block - for example on synchronous IO - I don't utilize my CPUs enough. what I want is four active threads at any given moment, for example - four threads which encrypt AES and another 140 threads which wait for the IO to finish.

this is what ForkJoinPool provides - if your task spawns new tasks and that task waits for them to finish - the pool will inject new active threads in order to saturate the CPU. it is worth mentioning that ForkJoinPool utilizes work stealing too.

which one to use? if you work with the fork-join model or you know your tasks block indefinitely, use the ForkJoinPool. if your tasks are short and are mostly CPU-bound, use newWorkStealingPool.

and after anything has being said, modern applications tend to use thread pool with the number of processors available and utilize asynchronous IO and lock-free-containers in order to prevent blocking. this (usually) gives the best performance.

回答2:

newWorkStealingPool is a higher level of abstraction for ForkJoinPool.

If you look at the Oracle jvm implementation, it's simply a preconfigured ForkJoinPool: public static ExecutorService newWorkStealingPool() { return new ForkJoinPool (Runtime.getRuntime().availableProcessors(), ForkJoinPool.defaultForkJoinWorkerThreadFactory, null, true); } Unfortunately looking at implementation isn't proper way for understanding purpose of a class though. Also credit to: https://dzone.com/articles/diving-into-java-8s-newworkstealingpools

回答3:

It's only a abstraction for the Fork/Join Framework...

/**
* Creates a work-stealing thread pool using all
* {@link Runtime#availableProcessors available processors}
* as its target parallelism level.
* @return the newly created thread pool
* @see #newWorkStealingPool(int)
* @since 1.8
*/
public static ExecutorService newWorkStealingPool() {
    return new ForkJoinPool(Runtime.getRuntime().availableProcessors(),
                            ForkJoinPool.defaultForkJoinWorkerThreadFactory,
                            null, true);
}