RecursiveAction

  1. public class ForkJoinPoolAction {
  2.     public static void main(String[] args) throws Exception{
  3.         PrintTask task = new PrintTask(0, 300);
  4.         ForkJoinPool pool = new ForkJoinPool();
  5.         pool.submit(task);
  6.         pool.awaitTermination(2, TimeUnit.SECONDS);
  7.         pool.shutdown();
  8.     }
  9. }
  11. class PrintTask extends RecursiveAction{
  12.     private static final int THRESHOLD = 50; //最多只能打印50个数
  13.     private int start;
  14.     private int end;
  16.     public PrintTask(int start, int end) {
  17.         super();
  18.         this.start = start;
  19.         this.end = end;
  20.     }
  22.     @Override
  23.     protected void compute() {
  25.         if(end - start < THRESHOLD){
  26.             for(int i=start;i<end;i++){
  27.                 System.out.println(Thread.currentThread().getName()+"的i值："+i);
  28.             }
  29.         }else {
  30.             int middle =(start+end)/2;
  31.             PrintTask left = new PrintTask(start, middle);
  32.             PrintTask right = new PrintTask(middle, end);
  33.             //并行执行两个“小任务”
  34.             left.fork();
  35.             right.fork();
  36.         }   
  37.     }   
  38. }

RecursiveTask

  1. public class ForJoinPollTask {
  3.     public static void main(String[] args) throws Exception {
  4.         int[] arr = new int[100];
  5.         Random random = new Random();
  6.         int total =0;
  7.         //初始化100个数组元素
  8.         for(int i=0,len = arr.length;i<len;i++){
  9.             int temp = random.nextInt(20);
  10.             //对数组元素赋值，并将数组元素的值添加到sum总和中
  11.             total += (arr[i]=temp);
  12.         }
  13.         System.out.println("初始化数组总和："+total);
  14.         SumTask task = new SumTask(arr, 0, arr.length);
  15. //        创建一个通用池，这个是jdk1.8提供的功能
  16.         ForkJoinPool pool = ForkJoinPool.commonPool();
  17.         Future<Integer> future = pool.submit(task); //提交分解的SumTask 任务
  18.         System.out.println("多线程执行结果："+future.get());
  19.         pool.shutdown(); //关闭线程池
  20.     }
  22. }
  25. class SumTask extends RecursiveTask<Integer>{
  26.     private static final int THRESHOLD = 20; //每个小任务 最多只累加20个数
  27.     private int arry[];
  28.     private int start;
  29.     private int end;
  32.     public SumTask(int[] arry, int start, int end) {
  33.         super();
  34.         this.arry = arry;
  35.         this.start = start;
  36.         this.end = end;
  37.     }
  39.     @Override
  40.     protected Integer compute() {
  41.         int sum =0;
  42.         //当end与start之间的差小于threshold时，开始进行实际的累加
  43.         if(end - start <THRESHOLD){
  44.             for(int i= start;i<end;i++){
  45.                 sum += arry[i];
  46.             }
  47.             return sum;
  48.         }else {//当end与start之间的差大于threshold，即要累加的数超过20个时候，将大任务分解成小任务
  49.             int middle = (start+ end)/2;
  50.             SumTask left = new SumTask(arry, start, middle);
  51.             SumTask right = new SumTask(arry, middle, end);
  52.             //并行执行两个 小任务
  53.             left.fork();
  54.             right.fork();
  55.             //把两个小任务累加的结果合并起来
  56.             return left.join()+right.join();
  57.         }       
  58.     }  
  59. }