Java ForkJoinPool commonPool() Method

The commonPool() method of ForkJoinPool class is used to return an instance of common Pool. Its running state is unaffected by the shutdown request.

Syntax:

Parameter:

No parameter is passed.

Returns:

Returns an instance of commonPool.

Throw

Does not throw Exception.

Example 1

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
 class Task4 extends RecursiveAction {
     private long Load = 0;
 public Task4(long Load) {
         this.Load = Load;
    }
    @Override
    protected void compute() {
        //if work is above threshold, break tasks up into smaller tasks
            List<Task4> subtasks = new ArrayList<Task4>();
                subtasks.addAll(createSubtasks());
            for(RecursiveAction subtask : subtasks){
                subtask.fork();
            }
    }
    private List<Task4> createSubtasks() {
        List<Task4> subtasks =new ArrayList<Task4>();
     Task4 subtask1 = new Task4(this.Load / 2);
     Task4 subtask2 = new Task4(this.Load / 2);
      Task4 subtask3 = new Task4(this.Load / 2);
        subtasks.add(subtask1);
        subtasks.add(subtask2);
        subtasks.add(subtask3);

        return subtasks;
    }
}
public class JavaForkJoincommonPoolExample1 {
   public static void main(final String[] arguments) throws InterruptedException
      {      
      int proc = Runtime.getRuntime().availableProcessors();
      System.out.println("numbers of core available in your processor:"  +proc);
      ForkJoinPool Pool = ForkJoinPool.commonPool();
      int i= Pool.getPoolSize();
      System.out.println("Common Pool Size before  :" +i);
       Task4 t = new Task4(400);
       Pool.invoke(t);
        i= Pool.getPoolSize();
      System.out.println("Common Pool Size after  :" +i);
   }  
}

Test it Now

Output:

numbers of core available in your processor:4
Common Pool Size before  :0
Common Pool Size after  :3

Example 2

import java.util.Random;
	import java.util.concurrent.ForkJoinPool;
	import java.util.concurrent.RecursiveTask;
        public class JavaForkJoincommonPoolExample2 extends RecursiveTask<Integer> {
          private static final int var = 5;
             private final int[] value;
             private final int st;
             private final int ed;
             //parameterized constructor
       public JavaForkJoincommonPoolExample2(int[] value, int st, int ed) {
	    this.value = value;
	    this.st = st;
	    this.ed = ed;
	  }
       public JavaForkJoincommonPoolExample2(int[] value) {
	    this(value, 0, value.length);
	  }
          @Override
	  protected Integer compute() {
	    final int length = ed - st;
	    if (length < var) {
	      return computeDirectly();
	    }
	    final int split = length / 2;
            //new class object 
	    JavaForkJoincommonPoolExample2 left = new JavaForkJoincommonPoolExample2(value, st, st + split);
	    left.fork();
             JavaForkJoincommonPoolExample2 right = new JavaForkJoincommonPoolExample2(value, st + split, ed);
	    return Math.max(right.compute(), left.join());
	  }
	  private Integer computeDirectly() {
	    System.out.println(Thread.currentThread() + " computing: " + st + " to " + ed);
	    int max = Integer.MIN_VALUE;
	    for (int i = st; i < ed; i++) {
	      if (value[i] > max) {
	        max = value[i];
	      }
	    }
	    return max;
	  }
	  public static void main(String[] args) {
	    // create a random data set
	    final int[] value = new int[100];
	    final Random rand = new Random();
	    for (int i = 0; i < value.length; i++) {
	      value[i] = rand.nextInt(100);
	    }
           // submit the task to the poool
           ForkJoinPool pool = ForkJoinPool.commonPool();
           JavaForkJoincommonPoolExample2 finder = new JavaForkJoincommonPoolExample2(value);
	    System.out.println(pool.invoke(finder));
	  }
	}

Test it Now

Output:

Thread[main,5,main] computing: 96 to 100
Thread[main,5,main] computing: 93 to 96
Thread[main,5,main] computing: 90 to 93
Thread[main,5,main] computing: 87 to 90
Thread[main,5,main] computing: 84 to 87
Thread[main,5,main] computing: 81 to 84
Thread[main,5,main] computing: 78 to 81
Thread[main,5,main] computing: 75 to 78
Thread[main,5,main] computing: 71 to 75
Thread[main,5,main] computing: 68 to 71
Thread[main,5,main] computing: 65 to 68
Thread[main,5,main] computing: 62 to 65
Thread[main,5,main] computing: 59 to 62
Thread[main,5,main] computing: 56 to 59
Thread[main,5,main] computing: 53 to 56
Thread[main,5,main] computing: 46 to 50
Thread[main,5,main] computing: 43 to 46
Thread[main,5,main] computing: 40 to 43
Thread[main,5,main] computing: 37 to 40
Thread[main,5,main] computing: 34 to 37
Thread[main,5,main] computing: 31 to 34
Thread[main,5,main] computing: 15 to 18
Thread[main,5,main] computing: 12 to 15
Thread[main,5,main] computing: 9 to 12
Thread[main,5,main] computing: 6 to 9
Thread[main,5,main] computing: 3 to 6
Thread[main,5,main] computing: 0 to 3
99

Next TopicForkjoinpool execute()

← prev next →