// 這個(gè)示例創(chuàng)建了一個(gè)并行級別為 4 的 ForkJoinPool。   如果是默認(rèn)構(gòu)造會(huì)自動(dòng)識別當(dāng)前電腦的cup核數(shù)進(jìn)行并行
ForkJoinPool forkJoinPool = new ForkJoinPool(4);

package com;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveAction;

public class MyRecursiveAction extends RecursiveAction {

    private long workLoad = 0;

    public MyRecursiveAction(long workLoad) {
        this.workLoad = workLoad;
    }

    @Override
    protected void compute() {

        //如果工作超出閾值，將任務(wù)分解成更小的任務(wù)
        if(this.workLoad > 10) {
            System.out.println("將工作負(fù)載 : " + this.workLoad);
            //將工作負(fù)載分成多個(gè)子任務(wù)
            List<MyRecursiveAction> subtasks =
                    new ArrayList<MyRecursiveAction>();
            subtasks.addAll(createSubtasks());
            //將子任務(wù)加入到任務(wù)隊(duì)列中
            for(RecursiveAction subtask : subtasks){
                subtask.fork();
            }
        } else {
            System.out.println("自己完成工作量: " + this.workLoad);
        }
    }
    //將工作負(fù)載分成多個(gè)子任務(wù)
    private List<MyRecursiveAction> createSubtasks() {
        List<MyRecursiveAction> subtasks = new ArrayList<MyRecursiveAction>();
        //將工作負(fù)載分成兩個(gè)子任務(wù)   24/2=12  12/2=6
        MyRecursiveAction subtask1 = new MyRecursiveAction(this.workLoad / 2);
        MyRecursiveAction subtask2 = new MyRecursiveAction(this.workLoad / 2);
        subtasks.add(subtask1);
        subtasks.add(subtask2);

        return subtasks;
    }

    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool(4);
        MyRecursiveAction myRecursiveAction = new MyRecursiveAction(24);
        forkJoinPool.invoke(myRecursiveAction);

    }

}

package com;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

//配置RecursiveTask，返回值為Long
public class MyRecursiveTask  extends RecursiveTask<Long> {

    private long workLoad = 0;

    public MyRecursiveTask (long workLoad) {
        this.workLoad = workLoad;
    }

    @Override
    protected Long compute() {

        //如果工作超出閾值，將任務(wù)分解成更小的任務(wù)
        if(this.workLoad > 10) {
            System.out.println("將工作負(fù)載 : " + this.workLoad);
            //將工作負(fù)載分成多個(gè)子任務(wù)
            List<MyRecursiveTask > subtasks = new ArrayList<MyRecursiveTask >();
            subtasks.addAll(createSubtasks());
            //將子任務(wù)加入到任務(wù)隊(duì)列中
            for(RecursiveTask subtask : subtasks){
                subtask.fork();
            }
            //等待子任務(wù)執(zhí)行完，并得到其結(jié)果,并將結(jié)果相加
            long result = 0;
            for(MyRecursiveTask subtask : subtasks) {
                result += subtask.join();
            }
            return result;
        } else {
            System.out.println("自己完成工作量: " + this.workLoad);
            return 1L ;//返回計(jì)算結(jié)果
        }
    }
    //將工作負(fù)載分成多個(gè)子任務(wù)
    private List<MyRecursiveTask > createSubtasks() {
        List<MyRecursiveTask > subtasks = new ArrayList<MyRecursiveTask >();
        //將工作負(fù)載分成兩個(gè)子任務(wù)   24/2=12  12/2=6
        MyRecursiveTask  subtask1 = new MyRecursiveTask (this.workLoad / 2);
        MyRecursiveTask  subtask2 = new MyRecursiveTask (this.workLoad / 2);
        subtasks.add(subtask1);
        subtasks.add(subtask2);
        return subtasks;
    }

    public static void main(String[] args) {
        ForkJoinPool forkJoinPool = new ForkJoinPool(4);
        MyRecursiveTask myRecursiveAction = new MyRecursiveTask(24);
        Long invoke = forkJoinPool.invoke(myRecursiveAction);
        System.out.println("最終結(jié)果: " + invoke);//4 從結(jié)果可以看出，任務(wù)被分成了4個(gè)子任務(wù)，每個(gè)子任務(wù)都是一個(gè)線程

    }

}

    public static void main(String[] args) {
        //開始時(shí)間
        Long start = System.currentTimeMillis();
        long sum = 0l;
        for (long i = 1; i <= 59999999999L; i++) {
            sum+=i;
        }
        System.out.println(sum); //結(jié)果為負(fù)數(shù),因?yàn)槌隽薼ong的最大值了   ,平均消耗時(shí)間:16秒
        //結(jié)束時(shí)間
        Long end = System.currentTimeMillis();
        System.out.println("消耗時(shí)間:"+(end-start));
    }

package com;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;

//配置RecursiveTask，返回值為Long
public class SumRecursiveTask   extends RecursiveTask<Long> {

    //大于3000要拆分(創(chuàng)建一個(gè)變量)
    //是否要拆分的臨界值
    private static final long THRESHOLD = 3000L;

    //起始值
    private final long start;
    //結(jié)束值
    private final long end;

    //構(gòu)造方法(傳遞起始值、結(jié)束值)
    public SumRecursiveTask(long start, long end) {
        this.start = start;
        this.end = end;
    }

    //任務(wù)編寫完成
    @Override
    protected Long compute() {
        long length = end - start;
        //計(jì)算
        if(length < THRESHOLD){
            long sum = 0;
            for (long i = start; i <= end; i++) {
                sum +=i;
            }
            return sum;
        }else{
            //拆分
            long middle = (start + end) /2;
            SumRecursiveTask left = new SumRecursiveTask(start,middle);//從小到大
            left.fork();
            SumRecursiveTask right = new SumRecursiveTask(middle+1,end);//從大到小
            right.fork();
            return left.join() +right.join();
        }
    }

    public static void main(String[] args) {
        Long start = System.currentTimeMillis();
        //放入線程池
        ForkJoinPool pool = new ForkJoinPool();
        SumRecursiveTask task = new SumRecursiveTask(1, 59999999999L);
        Long result = pool.invoke(task);
        System.out.println("result="+result); //結(jié)果為負(fù)數(shù),因?yàn)槌隽薼ong的最大值了   ,平均消耗時(shí)間:4秒
        Long end = System.currentTimeMillis();
        System.out.println("消耗時(shí)間:"+(end-start));
    }

}