submit() Method

The submit() method submits a Runnable task for execution and returns a Future representing that task. The Future's get method will return null upon successful completion.

Syntax

The submit() method is overloaded in the following ways:

public ForkJoinTask<?> submit(Runnable task)

public <T> ForkJoinTask<T> submit(Runnable task, T result)

public <T> ForkJoinTask<T> submit(Callable<T> task)

public <T> ForkJoinTask<T> submit(ForkJoinTask<T> task)

Parameter

task - the task to submit

Returns

Future representing the pending completion of the task

Throws

NullPointerException - if the task is null

RejectedExecutionException - if the task cannot be scheduled for execution

Example 1

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;
  class Taskk1 extends RecursiveAction {
     private long Load = 0;
  public Taskk1(long Load) {
         this.Load = Load;
    }
    @Override
    protected void compute() {
        //if work is above threshold, break tasks up into smaller tasks
            List<Taskk1> subtasks = new ArrayList<Taskk1>();
                     subtasks.addAll(createSubtasks());
            for(RecursiveAction subtask : subtasks){
                subtask.fork();
            } 
    }
   private List<Taskk1> createSubtasks() {
        List<Taskk1> subtasks =new ArrayList<Taskk1>();
     Taskk1 subtask1 = new Taskk1(this.Load / 2);
     Taskk1 subtask2 = new Taskk1(this.Load / 2);
      Taskk1 subtask3 = new Taskk1(this.Load / 2);
              subtasks.add(subtask1);
        subtasks.add(subtask2);
        subtasks.add(subtask3);
          return subtasks;
    }
}
public class JavaForkJoinsubmitExample1   {
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();
      System.out.println(" Before invoking number of active thread   :" +Pool.getActiveThreadCount());
       Taskk1 t = new Taskk1(400);
        System.out.println(" submit  :" +Pool.submit(t));
      }  
}

Test it Now

Output:

numbers of core available in your processor:4
 Before invoking number of active thread   :0
 submit  :Taskk1@55f96302

Example 2

import java.util.Random;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
        public class JavaForkJoinsubmitExample2 extends RecursiveTask<Integer> {
          private static final int var = 5;
             private final int[] value;
             private final int st;
             private final int ed;
             //parameterized constructor
       public JavaForkJoinsubmitExample2(int[] value, int st, int ed) {
	    this.value = value;
	    this.st = st;
	    this.ed = ed;
	  }
       public JavaForkJoinsubmitExample2(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 
	    JavaForkJoinsubmitExample2 left = new JavaForkJoinsubmitExample2(value, st, st + split);
	    left.fork();
            System.out.println("submit left :" +ForkJoinPool.commonPool().submit(left));
             JavaForkJoinsubmitExample2 right = new JavaForkJoinsubmitExample2(value, st + split, ed);
             System.out.println("submit left :" +ForkJoinPool.commonPool().submit(right));
	    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();
           JavaForkJoinsubmitExample2 finder = new JavaForkJoinsubmitExample2(value);
	    System.out.println(pool.invoke(finder));
           System.out.println("submit left :" +ForkJoinPool.commonPool().submit(finder));
	  }
	}

Test it Now

Output:

submit left :JavaForkJoinsubmitExample2@16019c77
submit left :JavaForkJoinsubmitExample2@18c670c7
submit left :JavaForkJoinsubmitExample2@55f96302
Thread[ForkJoinPool.commonPool-worker-2,5,main] computing: 0 to 2
submit left :JavaForkJoinsubmitExample2@3d4eac69
submit left :JavaForkJoinsubmitExample2@42a57993
Thread[ForkJoinPool.commonPool-worker-2,5,main] computing: 2 to 5
submit left :JavaForkJoinsubmitExample2@36dd1cc4
submit left :JavaForkJoinsubmitExample2@381ae46f
Thread[ForkJoinPool.commonPool-worker-2,5,main] computing: 2 to 5
Thread[ForkJoinPool.commonPool-worker-1,5,main] computing: 2 to 5
Thread[ForkJoinPool.commonPool-worker-3,5,main] computing: 0 to 2
Thread[ForkJoinPool.commonPool-worker-3,5,main] computing: 0 to 2
Thread[ForkJoinPool.commonPool-worker-2,5,main] computing: 0 to 2
submit left :JavaForkJoinsubmitExample2@75b84c92
Thread[main,5,main] computing: 7 to 10
Thread[ForkJoinPool.commonPool-worker-2,5,main] computing: 5 to 7
submit left :JavaForkJoinsubmitExample2@64dcdaac
Thread[ForkJoinPool.commonPool-worker-2,5,main] computing: 7 to 10
Thread[ForkJoinPool.commonPool-worker-2,5,main] computing: 2 to 5
Thread[ForkJoinPool.commonPool-worker-2,5,main] computing: 5 to 7
Thread[ForkJoinPool.commonPool-worker-2,5,main] computing: 7 to 10
Thread[ForkJoinPool.commonPool-worker-1,5,main] computing: 5 to 7
8
submit left :JavaForkJoinsubmitExample2@6bc7c054
submit left :JavaForkJoinsubmitExample2@6a1b3847
Thread[ForkJoinPool.commonPool-worker-3,5,main] computing: 7 to 10

Next TopicJava ForkJoinPool

← prev next →