The ForkJoinPool class is the center of the fork/join framework, which is an implementation of the ExecutorService interface. ForkJoinPool class is an extension of the AbstractExecutorService class, and it implements the work-stealing algorithm (i.e., worker threads that run out of things to do can steal tasks from other threads that are still busy) of fork/join framework and can execute ForkJoinTask processes.
The ForkJoinPool class inherits the following methods from java.util.concurrent.AbstractExecutorService class:
- invokeAll()
- invokeAny()
The ForkJoinPool class inherits the following methods from Methods inherited from class java.lang.Object class:
- clone()
- equals()
- finalize()
- getClass()
- hashCode()
- notify()
- notifyAll()
- wait()
Syntax:
public class ForkJoinPool extends AbstractExecutorService
Fork: Fork step splits the task into smaller subtasks and these tasks are executed concurrently.Â
Join: After the execution of the subtasks, the task may join all the results into one result.
This is illustrated in the diagram below:
Example:
getActiveThreadCount(): This method returns an estimated number of threads that are currently stealing or executing tasks. It may overestimate the number of active threads.
Syntax
public int getActiveThreadCount()
Java
// Java program to demonstrate the// Implementation of getActiveThreadCount()Â
import java.util.ArrayList;import java.util.List;import java.util.concurrent.ForkJoinPool;import java.util.concurrent.RecursiveAction;class NewTask extends RecursiveAction{Â Â Â Â private long Load = 0;Â Â Â Â Â Â Â Â Â public NewTask(long Load) { this.Load = Load; }Â
    protected void compute()    {        // fork tasks into smaller subtasks        List<NewTask> subtasks = new ArrayList<NewTask>();        subtasks.addAll(createSubtasks());                 for (RecursiveAction subtask : subtasks) {            subtask.fork();        }    }         // function to create and add subtasks    private List<NewTask> createSubtasks()    {        // create subtasks        List<NewTask> subtasks = new ArrayList<NewTask>();        NewTask subtask1 = new NewTask(this.Load / 2);        NewTask subtask2 = new NewTask(this.Load / 2);        NewTask subtask3 = new NewTask(this.Load / 2);                 // to add the subtasks        subtasks.add(subtask1);        subtasks.add(subtask2);        subtasks.add(subtask3);                 return subtasks;    }}public class JavaForkJoingetActivethreadcountExample1 {    public static void main(final String[] arguments)        throws InterruptedException    {        // get no. of available core available        int proc = Runtime.getRuntime().availableProcessors();                 System.out.println("Number of available core in the processor is: "            + proc);                     // get no. of threads active        ForkJoinPool Pool = ForkJoinPool.commonPool();                 System.out.println("Number of active thread before invoking: "            + Pool.getActiveThreadCount());                     NewTask t = new NewTask(400);                 Pool.invoke(t);                 System.out.println("Number of active thread after invoking: "            + Pool.getActiveThreadCount());        System.out.println("Common Pool Size is: "                           + Pool.getPoolSize());    }} |
Â
Â
Output
Number of available core in the processor is: 4 Number of active thread before invoking: 0 Number of active thread after invoking: 3 Common Pool Size is: 3
Methods of ForkJoinPool Class
|
METHOD |
DESCRIPTION |
|---|---|
| public boolean awaitQuiescence(long timeout, TimeUnit unit) | This method executes pool until the pool is quiescent, otherwise, assist performing tasks until specified time value and unit elapses or the pool is quiescent. |
| public boolean awaitTermination(long timeout, TimeUnit unit)Â | This method blocks until all tasks have completed execution after a shutdown request, or the timeout occurs, or the current thread is interrupted, whichever happens first. |
| public static ForkJoinPool commonPool() | This method returns the common pool instance. |
| public void execute(Runnable task) | This method executes the given command at some time in the future. |
| public int getActiveThreadCount() | This method returns an estimated number of threads that are currently stealing or executing tasks. It may overestimate the number of active threads. |
| public boolean getAsyncMode() | This method returns true if this pool uses local first-in-first-out scheduling mode for forked tasks that are never joined. |
| public static int getCommonPoolParallelism() | This method returns the targeted parallelism level of the common pool. |
| public ForkJoinPool.ForkJoinWorkerThreadFactory getFactory() | This method returns the factory used for constructing new workers. |
| public int getParallelism() | This method returns the targeted parallelism level of this pool. |
| public int getPoolSize() | This method returns the number of worker threads that have started but not yet terminated. |
| public int getQueuedSubmissionCount() | This method returns an estimate of the number of tasks submitted to this pool that have not yet begun executing. |
| public long getQueuedTaskCount() | This method returns an estimate of the total number of tasks currently held in queues by worker threads |
| public int getRunningThreadCount() | This method returns an estimate of the number of worker threads that are not blocked waiting to join tasks or for other managed synchronization. |
| public long getStealCount() | This method returns an estimate of the total number of tasks stolen from one thread’s work queue by another. |
| public Thread.UncaughtExceptionHandler getUncaughtExceptionHandler() | This method returns the handler for internal worker threads that terminate due to unrecoverable errors encountered while executing tasks. |
| public boolean hasQueuedSubmissions() | This method returns true if there are any tasks submitted to this pool that have not yet begun executing. |
| public <T> T invoke(ForkJoinTask<T> task) | This method performs the given task and returns its result upon completion. |
| public boolean isQuiescent() | This method returns true if all worker threads are currently idle. |
| public boolean isShutdown() | This method returns true if the pool calling isShutdown() has been shut down. |
| public boolean isTerminated() | This method returns true if all tasks have completed following shut down. |
| public boolean isTerminating() | This method returns true if the process of termination has started but not yet completed. |
| protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) | This method returns a RunnableFuture which, when run, will call the underlying callable and which, as a Future, will yield the callable’s result as its result and provide for cancellation of the underlying task. |
| public void shutdown() | This method returns true if this pool has been shut down. |
| public List<Runnable> shutdownNow() | This method possibly attempts to cancel and/or stop all tasks, and reject all subsequently submitted tasks. |
| public ForkJoinTask<?> submit(Runnable task) | This method submits a Runnable task for execution and returns a Future representing that task. |
| public String toString() | This method returns a string identifying this pool, as well as its state, including indications of run state, parallelism level, and worker and task counts. |
Â
[…] Fork/Join framework provides fine-grained task execution framework with high performance for Java data parallelism. Its […]