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

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

ForkjoinTask<V>:描述任务的抽象类 

ForkJoinPool：管理ForkJoinTask的线程池

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

RecursiveTask<V>: 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>{

        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 <end ; i++) {
                    sum +=i;
                }
            }else{//如果大于1000， 就把他拆分成两个子任务进行fork

                int mid= (end+begin)/2;

                MC left=new MC(begin,mid);//一部分小线程
                left.fork();//开启这小部分线程

                MC right= new MC(mid,end);

                right.fork();


                Long li= left.join();//让left任务完整完成

                Long lr= right.join();//让right任务完整完成

                sum=li+lr;

            }
            return sum;
        }
    }


    public static void main(String[] args) throws  Exception{

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

        Future<Long> ft=forkJoinPool.submit(new MC(0,100001));//在线程池中进行计算

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

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

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

第一个：先重写

RecursiveTask<V>的抽象类

package ForkJoinTest;

import java.util.concurrent.RecursiveTask;

/**
 * 重写RecursiveTask<V>的抽象类
 * Created by T430 on 2017/8/15.
 */
public abstract class ForkJoinService<V> extends RecursiveTask<V> {
    @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<List<String>> {

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


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

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

        //当end与start之间的差小于阈值时，开始进行实际筛选
        if (li.size()<threshold){
            for (String s:li
                 ) {
                if (s.contains("a")){//如果含有字母a，则添加进去
                    newList.add(s);
                }else{
                    continue;
                }
            }
        }else{
            // 如果当end与start之间的差大于阈值时,将大任务分解成两个小任务。
           int middles=li.size()/2;

           List<String> leftli= li.subList(0,middles);

           List<String> 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<String> stringList =new ArrayList<String>(Arrays.asList(strings));//把数组转换成list集合

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

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


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

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

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