forkjion框架 分而治之 适合的业务场景应该很好用

简单的讲讲forkjion 简单理解就是单机版的mapreduce

通过任务切片的  组合的方式 异步处理任务

现在 对于 实现原理进行简单介绍，有些摘自网络

•  Fork/Join框架的介绍

我们已经很清楚Fork/Join框架的需求了，那么我们可以思考一下，如果让我们来设计一个Fork/Join框架，该如何设计？这个思考有助于你理解Fork/Join框架的设计。

第一步分割任务。首先我们需要有一个fork类来把大任务分割成子任务，有可能子任务还是很大，所以还需要不停的分割，直到分割出的子任务足够小。

第二步执行任务并合并结果。分割的子任务分别放在双端队列里，然后几个启动线程分别从双端队列里获取任务执行。子任务执行完的结果都统一放在一个队列里，启动一个线程从队列里拿数据，然后合并这些数据。

Fork/Join使用两个类来完成以上两件事情：

• ForkJoinTask：我们要使用ForkJoin框架，必须首先创建一个ForkJoin任务。它提供在任务中执行fork()和join()操作的机制，通常情况下我们不需要直接继承ForkJoinTask类，而只需要继承它的子类，Fork/Join框架提供了以下两个子类：
  • RecursiveAction：用于没有返回结果的任务。
  • RecursiveTask ：用于有返回结果的任务。
• ForkJoinPool ：ForkJoinTask需要通过ForkJoinPool来执行，任务分割出的子任务会添加到当前工作线程所维护的双端队列中，进入队列的头部。当一个工作线程的队列里暂时没有任务时，它会随机从其他工作线程的队列的尾部获取一个任务。

• 使用Fork/Join框架

  让我们通过一个简单的需求来使用下Fork／Join框架，需求是：计算1+2+3+4的结果。

  使用Fork／Join框架首先要考虑到的是如何分割任务，如果我们希望每个子任务最多执行两个数的相加，那么我们设置分割的阈值是2，由于是4个数字相加，所以Fork／Join框架会把这个任务fork成两个子任务，子任务一负责计算1+2，子任务二负责计算3+4，然后再join两个子任务的结果。

因为是有结果的任务，所以必须继承RecursiveTask，实现代码如下：

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

public class CountTask extends RecursiveTask<Integer> {
    private int threshold =3;
    private int start;
    private int end;

    public static void main(String[] args) {
        ForkJoinPool forkjoinPool = new ForkJoinPool();

        ForkJoinTask<Integer> result = forkjoinPool.submit(new CountTask(1,100));

        try {
            System.out.println(result.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

    public CountTask(int start, int end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Integer compute() {
        int sum=0;
        boolean cancopute=end-start<threshold;
        if(cancopute){
            for(int i=start;i<=end;i++){
                sum+=i;
            }
        }else {
            int middle=(start+end)/2;
            CountTask leftCount=new CountTask(start,middle);
            CountTask rightCount=new CountTask(middle+1,end);
            leftCount.fork();
            rightCount.fork();
            Integer leftjoin = leftCount.join();
            Integer rightjoin = rightCount.join();
            sum=leftjoin+rightjoin;

        }

        return sum;
    }
}

下面是是一个相对复杂的demo

主要根据数组是否是1进行切分，放到队列里面进行记录，fork完毕，在进行join

package com.rongtuo.ux.forkjion;

import java.util.ArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

public class ComposeTask extends RecursiveTask<String> {
    private String[] urls;
    private String[] args;
    public static void main(String args[]) throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        System.out.println(System.currentTimeMillis());
        ForkJoinPool forkJoinPool = new ForkJoinPool(1);
        String[] urls = {"http://localhost:8080/uc/getUser","http://localhost:8080/uc/addUser",
                "http://localhost:8080/uc/getUser2","http://localhost:8080/uc/addUser2",
                "http://localhost:8080/uc/getUser3","http://localhost:8080/uc/addUser3",
                "http://localhost:8080/uc/getUser4","http://localhost:8080/uc/addUser4"};
        String[] argus = {};
        ComposeTask task = new ComposeTask(urls, argus);
        ForkJoinTask<String> result = forkJoinPool.submit(task);
        String rsp = result.get();
        long end = System.currentTimeMillis();
        System.out.println(end-start);
        System.out.println("fork/join rsp = " + rsp);
    }

    public ComposeTask(String[] urls, String[] args) {
        this.urls = urls;
        this.args = args;
    }

    @Override
    protected String compute() {
        String rtn = new String();
        if (urls.length == 1) {
            //执行url
            rtn = urls[0] + " || ";
            try {
                //模拟执行网络请求
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            ArrayList<ComposeTask> subTasks = new ArrayList<ComposeTask>();
            for (String url : urls) {
                String[] arrayUrl = {url};
                ComposeTask subTask = new ComposeTask(arrayUrl, args);
                subTasks.add(subTask);
                subTask.fork();
            }

            for (ComposeTask t : subTasks) {
                rtn = rtn + t.join();
            }
        }
        return rtn;
    }
}