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框架就结束了, 大家对这个框架还有什么想深入了解的,具体的讲解呢, 推荐给大家:框架介绍,看下这个


你可能感兴趣的:(高并发)