The Java Fork-Join Pool Framework

Question 1

The _ provides a high performance, parallel, fine-grained task execution framework for Java programs.

Answer 1

ForkJoinPool

Question 2

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).

Answer 2

work-stealing

Question 3

It provides a parallel computing engine for many higher-level frameworks.

Answer 3

ForkJoinPool

Question 4

_ is a feature of Java 8 and higher, meant for utilizing multiple cores of the processor.

Answer 4

Java Parallel Streams

Question 5

Java Parallel Streams is a feature of _ and higher, meant for utilizing multiple cores of the processor.

Answer 5

Java 8

Question 6

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).

Answer 6

parallel stream

Question 7

A _ is a flow of objects that supports various functions and is intended to produce a reliable output.

Answer 7

parallel stream

Question 8

_ in Java is simply a wrapper around a data source, allowing us to perform bulk operations on the data in a convenient way.

Answer 8

Stream

Question 9

_ 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.

Answer 9

Parallel streams

Question 10

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.

Answer 10

separate, change

Question 11

Parallel streams make use of the _ and its common pool of worker threads.

Answer 11

fork-join framework

Question 12

The fork-join framework was added to _ in Java 7 to handle task management between multiple threads.

Answer 12

java.util.concurrent

Question 13

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.

Answer 13

Noted

Question 14

_ is an Executor Service implementation.

Answer 14

Fork-Join Pool

Question 15

_ is the basis for Java Executor framework sublasses.

Answer 15

Executor Service

Question 16

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.

Answer 16

Noted

Question 17

The Java ExecutorService is a _ that allows you to pass a task to be executed by a thread _.

Answer 17

construct, asynchronously

Question 18

The Java ExecutorService creates and maintains a reusable _ for executing submitted tasks.

Answer 18

pool of threads

Question 19

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.

Answer 19

queue

Question 20

Other implementations Executor Service of execute runnables and callables.

Answer 20

AbstractExecutorService

Question 21

_ defines methods that enable non-ForkJoinTask clients to process ForkJoinTasks.

Answer 21

ForkJoinPool

Question 22

ForkJoinPool executes _.

Answer 22

fork/join tasks

Question 23

ForkJoinPool

These methods insert new _ onto a shared queue used to feed _ queues managed by worker threads.

Answer 23

tasks, unshared

Question 24

A ForkJoinTask associates a chunk of data along with a computation on that data, which enables _.

Answer 24

fine-grained parallelism

Question 25

A program is broken down to a large number of small tasks.

Answer 25

Fine-grained parallelism

Question 26

**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**.

Answer 26

Noted

Question 27

A ForkJoinTask is _ weight than a Java thread.

Answer 27

lighter

Question 28

A _ number of ForkJoinTasks can thus run in a _ number of worker threads in a fork-join pool.

Answer 28

large, small

Question 29

A ForkJoinTask has two methods that control parallel processing/merging:

Answer 29

**fork()** - Arranges to **asynchronously** execute this task in the appropriate pool. **join()** - Returns the result of the computation when it is done.

Question 30

fork() arranges to _ execute a ForkJoinTask in the appropriate pool.

Answer 30

asynchronously

Question 31

join() returns the _ of the computation when it is done.

Answer 31

result

Question 32

Programs **rarely** use the ForkJoinTask class directly but instead extend one of its subclasses & override compute() **RecursiveAction **RecursiveTask **CountedCompleter

Answer 32

Noted

Question 33

Each worker thread in a fork-join pool maintains its own _.

Answer 33

double ended queue (deque)

Question 34

The Java fork-join framework implements this deque via the _ class.

Answer 34

WorkQueue

Question 35

A worker threads processes its own deque in _ order by popping (sub)-task from of its own deque.

Answer 35

LIFO (Last In First Out)

Question 36

To maximize core utilization, idle worker threads _ work from the tail of busy threads' deques

Answer 36

steal

Question 37

Idle worker threads steal work from the tail of busy threads' deques to _ core utilization.

Answer 37

maximize

Question 38

Tasks are stolen in _ order since an older stolen task may provide a larger unit of work.

Answer 38

FIFO

Question 39

Java Fork-Join Framework Internals enable further recursive _ by the stealing thread.

Answer 39

decompositions

Question 40

The _ deque that implements work-stealing minimizes locking contention.

Answer 40

WorkQueue deque

Question 41

The Workqueue deque that implements work-stealing _ locking contention.

Answer 41

minimizes

Question 42

_ and _ are called by the owning worker thread. These operations use wait-free "compare-and-swap" (CAS) operations.

Answer 42

push(), pop()

Question 43

Adds an element to the top of the stack.

Answer 43

push()

Question 44

Removes the topmost element from the stack.

Answer 44

pop()

Question 45

Push() and pop() use wait-free _ operations.

Answer 45

"compare-and-swap" (CAS)

Question 46

_ may be called from another worker thread to steal a (sub-)task.

Answer 46

Poll()

Question 47

Poll may be called from another worker thread to _ a (sub-)task.

Answer 47

steal

Question 48

A _ is used for asynchronous programming.

Answer 48

CompletableFuture

Question 49

A CompletableFuture is used for _ programming.

Answer 49

asynchronous

Question 50

Asynchronous programming means writing _ code.

Answer 50

non-blocking

Question 51

CompletableFuture runs a task on a _ thread from the main application thread and notifies the main thread about its progress, completion, or failure.

Answer 51

separate

Question 52

In CompletableFuture, the main thread does not _ or _ for the completion of the task.

Answer 52

block, wait

Question 53

In CompletableFuture, other tasks are executed in _.

Answer 53

parallel

Question 54

_ improves the performance of the program.

Answer 54

Parallelism

Question 55

# **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**.

Answer 55

Noted

Question 56

# 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.

Answer 56

few

Question 57

# Fork/Join Framework Guidelines Use the _ common thread pool if no specific tuning is needed.

Answer 57

default

Question 58

# Fork/Join Framework Guidelines Use a reasonable threshold for splitting _ into subtasks.

Answer 58

ForkJoinTask

Question 59

# Fork/Join Framework Guidelines Avoid any _ in ForkJoinTasks.

Answer 59

blocking