forkjoin并发分页查数据_java fork join

为什么用 Fork/Join ？

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.RecursiveTask;
public class forkjoin {
    public static void main(String[] args) {
        //创建分治任务线程池
        ForkJoinPool fjp = new	ForkJoinPool(4);
        //创建分治任务
        Fibonacci fib = new	Fibonacci(30);
        //启动分治任务
        Long start_time = System.currentTimeMillis();
        Integer	result = fjp.invoke(fib);
        //输出结果
        Long end_time = System.currentTimeMillis();
        Long compute_time = end_time - start_time;
        System.out.println("result: "+result);
        System.out.println("forkjoin compute_time: "+ compute_time);
    }
    //递归任务
    static class Fibonacci extends RecursiveTask<Integer>{
        final	int	n;
        Fibonacci(int	n){this.n	=	n;}
        protected	Integer	compute(){
            if(n<=1) 
                return n;
            Fibonacci f1 = new Fibonacci(n-1);
            //创建⼦任务
            f1.fork();
            Fibonacci f2 = new Fibonacci(n-2);
            //等待⼦任务结果，并合并结果
            return f2.compute()+f1.join();
        }
    }
}

普通单线程计算斐波那契数列

public class fibonacci {
    public static void main(String[] args) {
        Fibonacci fib = new	Fibonacci(30);
        Long start_time = System.currentTimeMillis();
        Integer	result = fib.compute();
        Long end_time = System.currentTimeMillis();
        Long compute_time = end_time - start_time;
        System.out.println("result: "+result);
        System.out.println("compute_time: "+ compute_time);
    }
    //递归任务
    static class Fibonacci {
        final int n;
        Fibonacci(int n){
            this.n = n;
        }
        protected	Integer	compute(){
            //终止条件
            if(n<=1)
                return	n;
            //创建⼦任务
            Fibonacci f1 = new	Fibonacci(n-1);
            Fibonacci f2 = new	Fibonacci(n-2);
            //等待⼦任务结果，并合并结果
            return f2.compute()+f1.compute();
        }
    }
}

分别执行，会发现普通计算的方式会更快，说明forkjoin在调度方面会有很大的性能消耗。

在终止条件下加上一条休眠语句，使每次计算都要持续设定时间以上，再对比两种方式的速度。

 Fibonacci fib = new	Fibonacci(5);

 //终止条件
if(n<=1) {
    if(n<=1) {
         try {
              Thread.sleep(1000);
         }catch (Exception e){
              e.printStackTrace();
         }
         return n;
     }
}

可以发现并行的计算方式的执行速度，与设定的的线程数量有关，比如第五个斐波那契数列的值，需要分解为8次计算任务，每次至少需要8秒。普通计算方式需要8秒，并行计算方式在线程数为4的情况下，执行时间为2秒；线程数为8的情况下，执行时间为1秒。实际执行速度应与CPU的核数有关，即如果CPU只有4核，就算设置为8线程，最快速度也只有2秒（示例中执行时间为1秒是因为采用线程休眠来模拟该线程的总处理时间，实际该线程在休眠期间并不消耗计算资源）

使用Fork/Join需要注意的地方

在使用Fork/Join时，需要注意出现工作线程不工作的事情。下面从不同的使用方式来分析： fork() 和 compute() 。

  在示例中，下面这句语句是分解任务以及合并任务的关键

 f1.fork();
//等待⼦任务结果，并合并结果
return f2.compute()+f1.join();

 主线程分配了一个任务给子线程，同时自己也执行一次计算任务。

方式1： a.fork(); b.fork(); b.join(); a.join();

f1.fork();
f2.fork();
return f2.join()+f1.join();

  这种使用方式内部做了很多优化，目的都是为了避免出现工作线程只分配任务而不执行任务的情况。

方式2：invokeAll（a,b）

invokeAll(f1, f2);
return f2.join()+f1.join();

    invokeAll的N个任务中，其中N-1个任务会使用fork()交给其它线程执行，但是，它还会留一个任务自己执行，这样，就充分利用了线程池，保证没有空闲的不干活的线程。 

方式3：a.fork(); b.fork(); a.join(); b.join();    （错误的使用方式，不建议使用）

f1.fork();
f2.fork();
return f1.join()+f2.join();

       这种使用方式会出现工作线程只分配任务给子线程，自己却不执行任务的情况。比如某个任务可以分为四个子任务，线程a把任务分给线程b线程c，而线程b线程c又继续分给自己的子线程（b分解为b1和b2 / c分解为c1和c2)，总共需要7个线程，但是abc却不参与计算。而第一种使用方法，Java内部做了优化。

总结

用两次fork()在join的时候，需要用这样的顺序：a.fork(); b.fork(); b.join(); a.join();这个要求在JDK官方文档里有说明。

建议使用fork() 和 compute() ，这样可以避免避免性能问题，且更容易理解。该用法可理解为在主线程中使用fork分解一次任务，同时该线程执行一次compute 计算，如果该compute计算还需要分解任务，则继续fork() 和 compute(），直到满足终止条件直接返回。因此主线程会不断分解任务，直到任务无法分解并计算该任务返回计算结果。即主线程的处理任务是分解n/2 次任务以及执行一次无法分解的任务。

参考 ：

https://www.liaoxuefeng.com/article/001493522711597674607c7f4f346628a76145477e2ff82000 

https://time.geekbang.org/discuss/detail/90130/