The Java Fork-Join Pool Framework Flashcards
The _ provides a high performance, parallel, fine-grained task execution framework for Java programs.
ForkJoinPool
A ForkJoinPool distinguishes itself from other types of ExecutorService primarily through its use of _: every thread in the pool seeks to locate and perform tasks that have been submitted to the pool or generated by other currently active tasks (ultimately blocking and waiting for work if none is available).
work-stealing
It provides a parallel computing engine for many higher-level frameworks.
ForkJoinPool
_ is a feature of Java 8 and higher, meant for utilizing multiple cores of the processor.
Java Parallel Streams
Java Parallel Streams is a feature of _ and higher, meant for utilizing multiple cores of the processor.
Java 8
Using the _, we can divide chunks of code into streams that execute in parallel on multiple cores. The final result is the grouping of the different results (outcomes).
parallel stream
A _ is a flow of objects that supports various functions and is intended to produce a reliable output.
parallel stream
_ in Java is simply a wrapper around a data source, allowing us to perform bulk operations on the data in a convenient way.
Stream
_ enable us to execute code in parallel on separate cores. The final result is the combination of each outcome. However, the order of execution is out of our control. It may change every time we run the program.
Parallel streams
Parallel streams enable us to execute code in parallel on _ cores. The final result is the combination of each outcome. However, the order of execution is out of our control. It may _ every time we run the program.
separate, change
Parallel streams make use of the _ and its common pool of worker threads.
fork-join framework
The fork-join framework was added to _ in Java 7 to handle task management between multiple threads.
java.util.concurrent
By using the parallel stream, we can divide chunks of code into streams that execute in parallel on multiple cores. It is advisable to use parallel streams in such a case where the sequence of execution does not matter and the result will not be affected. Also, notable that the state of one element does not affect the other as well as the source of the data remains unaffected.
Noted
_ is an Executor Service implementation.
Fork-Join Pool
_ is the basis for Java Executor framework sublasses.
Executor Service
The Java ExecutorService
* is a construct that allows you to pass a task to be executed by a thread asynchronously.
* creates and maintains a reusable pool of threads for executing submitted tasks.
* also manages a queue, which is used when there are more tasks than the number of threads in the pool and there is a need to queue up tasks until there is a free thread available to execute the task.
Noted
The Java ExecutorService is a _ that allows you to pass a task to be executed by a thread _.
construct, asynchronously
The Java ExecutorService creates and maintains a reusable _ for executing submitted tasks.
pool of threads
The Java ExecutorService manages a _, which is used when there are more tasks than the number of threads in the pool and there is a need to queue up tasks until there is a free thread available to execute the task.
queue
Other implementations Executor Service of execute runnables and callables.
AbstractExecutorService
_ defines methods that enable non-ForkJoinTask clients to process ForkJoinTasks.
ForkJoinPool
ForkJoinPool executes _.
fork/join tasks
ForkJoinPool
These methods insert new _ onto a shared queue used to feed _ queues managed by worker threads.
tasks, unshared
A ForkJoinTask associates a chunk of data along with a computation on that data, which enables _.
fine-grained parallelism
A program is broken down to a large number of small tasks.
Fine-grained parallelism
Fine-Grained Parallelism
* These tasks are assigned individually to many processors.
* The amount of work associated with a parallel task is low and the work is evenly distributed among the processors.
* fine-grained parallelism facilitates load balancing.
Noted
A ForkJoinTask is _ weight than a Java thread.
lighter
A _ number of ForkJoinTasks can thus run in a _ number of worker threads in a fork-join pool.
large, small
A ForkJoinTask has two methods that control parallel processing/merging:
fork() - Arranges to asynchronously execute this task in the appropriate pool.
join() - Returns the result of the computation when it is done.
fork() arranges to _ execute a ForkJoinTask in the appropriate pool.
asynchronously
join() returns the _ of the computation when it is done.
result
Programs rarely use the ForkJoinTask class directly but instead extend one of its subclasses & override compute()
**RecursiveAction
**RecursiveTask
**CountedCompleter
Noted
Each worker thread in a fork-join pool maintains its own _.
double ended queue (deque)
The Java fork-join framework implements this deque via the _ class.
WorkQueue
A worker threads processes its own deque in _ order by popping (sub)-task from of its own deque.
LIFO (Last In First Out)
To maximize core utilization, idle worker threads _ work from the tail of busy threads’ deques
steal
Idle worker threads steal work from the tail of busy threads’ deques to _ core utilization.
maximize
Tasks are stolen in _ order since an older stolen task may provide a larger unit of work.
FIFO
Java Fork-Join Framework Internals enable further recursive _ by the stealing thread.
decompositions
The _ deque that implements work-stealing minimizes locking contention.
WorkQueue deque
The Workqueue deque that implements work-stealing _ locking contention.
minimizes
_ and _ are called by the owning worker thread. These operations use wait-free “compare-and-swap” (CAS) operations.
push(), pop()
Adds an element to the top of the stack.
push()
Removes the topmost element from the stack.
pop()
Push() and pop() use wait-free _ operations.
“compare-and-swap” (CAS)
_ may be called from another worker thread to steal a (sub-)task.
Poll()
Poll may be called from another worker thread to _ a (sub-)task.
steal
A _ is used for asynchronous programming.
CompletableFuture
A CompletableFuture is used for _ programming.
asynchronous
Asynchronous programming means writing _ code.
non-blocking
CompletableFuture runs a task on a _ thread from the main application thread and notifies the main thread about its progress, completion, or failure.
separate
In CompletableFuture, the main thread does not _ or _ for the completion of the task.
block, wait
In CompletableFuture, other tasks are executed in _.
parallel
_ improves the performance of the program.
Parallelism
CONCLUSION
- The ForkJoinPool framework in Java offers a powerful and effective approach to parallel programming, especially for algorithms that utilize divide-and-conquer strategies. By using the strategy work-stealing algorithm, it efficiently coordinates task execution among several threads, enhancing resource use and boosting performance.
- Using the fork/join framework can speed up the processing of large tasks, but to achieve this outcome, we should follow some guidelines:
—Use as few thread pools as possible. In most cases, the best decision is to use one thread pool per application or system.
—Use the default common thread pool if no specific tuning is needed.
—Use a reasonable threshold for splitting ForkJoinTask into subtasks.
—Avoid any blocking in ForkJoinTasks.
Noted
Fork/Join Framework Guidelines
Use as _ thread pools as possible. In most cases, the best decision is to use one thread pool per application or system.
few
Fork/Join Framework Guidelines
Use the _ common thread pool if no specific tuning is needed.
default
Fork/Join Framework Guidelines
Use a reasonable threshold for splitting _ into subtasks.
ForkJoinTask
Fork/Join Framework Guidelines
Avoid any _ in ForkJoinTasks.
blocking
