Fork/Join框架的简单学习和简单demo

对于高并发来说，这一直是痛点，  今天有学 了下Fork/Join框架，其中他的主要类有以下几种：

ForkjoinTask:描述任务的抽象类 

ForkJoinPool：管理ForkJoinTask的线程池

RecursiveAction:ForkJoinTask子类，描述无返回值的任务

RecursiveTask: ForkJoinTask子类，描述有返回值的任务

这个框架的策略是分而治之：将任务地柜划分成更小的子任务， 直到子任务足够小，从而能够被连续的处理掉为止

    优点：处理过程中可以使用并行发生，这种情况特别适合基于多核处理器的并行编程。

下面就写一个小例子来演示下这个框架的应用：

import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;
import java.util.concurrent.RecursiveTask;

/**
 * Fork/Join框架demo
 * Created by T430 on 2017/8/14.
 */
public class ForkJoinDemo {

    private static  int THRESLOD=1000;//任务阈值

    /**
     * 求1到100万之间的和，因为需要返回结果，所以需要继承recursiverTask
     */
  static class  MC extends RecursiveTask{

        Long sum = Long.valueOf(0);

        private  int begin,end;

        public MC(int begin, int end){
            this.begin=begin;
            this.end=end;
        }

        //表示这个任务完成后，返回的一个值
        @Override
        protected Long compute() {

            //如果任务量小于阈值，就直接计算
            if ((end-begin)<=THRESLOD){
                for (int i = begin; i  ft=forkJoinPool.submit(new MC(0,100001));//在线程池中进行计算

        System.out.println("计算的结果是："+ft.get());

        forkJoinPool.shutdown();//关闭线程池
    }
}

第二个例子：  查询出数组里包含a的字段，并显示：  下面是demo

第一个：先重写

RecursiveTask的抽象类

package ForkJoinTest;

import java.util.concurrent.RecursiveTask;

/**
 * 重写RecursiveTask的抽象类
 * Created by T430 on 2017/8/15.
 */
public abstract class ForkJoinService extends RecursiveTask {
    @Override
    protected abstract V compute();
}

第二步：

package ForkJoinTest;

import java.util.ArrayList;
import java.util.List;

/**
 * ForkJoin的基类
 * Created by T430 on 2017/8/15.
 */
public class ForkJoinTest extends ForkJoinService> {

    private  int threshold;//阈值
    private  List li;//待拆分list


    public ForkJoinTest(int threshold, List li) {
        this.threshold = threshold;
        this.li = li;
    }

    @Override
    protected List compute() {
        
        List newList=new ArrayList();//保存含有a字母的新集合

        //当end与start之间的差小于阈值时，开始进行实际筛选
        if (li.size() leftli= li.subList(0,middles);

           List rightli=li.subList(middles,li.size());

           ForkJoinTest left= new ForkJoinTest(threshold,leftli);

           ForkJoinTest right=new ForkJoinTest(threshold,rightli);

           //并行执行两个小任务
            left.fork();
            right.fork();

            //把两个小任务的结果“集合”起来
            newList.addAll(left.join());
            newList.addAll(right.join());
        }


        return newList;
    }
}

第三步：测试：

package ForkJoinTest;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.Future;

/**
 * 测试类
 * Created by T430 on 2017/8/15.
 */
public class TestMain {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        String[] strings = {"a", "ah", "b", "ba", "ab", "ac", "sd", "fd", "ar", "te", "se", "te",
                "sdr", "gdf", "df", "fg", "gh", "oa", "ah", "qwe", "re", "ty", "ui", "al"};

        List stringList =new ArrayList(Arrays.asList(strings));//把数组转换成list集合

        ForkJoinPool forkJoinPool =new ForkJoinPool();//创建他的线程池

        // 提交可分解的ForkJoinTask任务
        Future> ft=forkJoinPool.submit(new ForkJoinTest(20,stringList));


        System.out.println("查询的结果是："+ft.get()+",个数是："+ft.get().size());

        forkJoinPool.shutdown();//关闭线程池
    }
}

到处为止，Fork/Join框架就结束了， 大家对这个框架还有什么想深入了解的，具体的讲解呢， 推荐给大家：框架介绍，看下这个