ForkJoinPool Class in Java with Examples

0 0 4 minutes read

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.