Fork/Join框架及模拟业务代码实现

1.什么是Fork/Join框架

加入qq群，与博主共享知识库：778444458；群内有各种学习资料可供学习
Fork/Join框架是Java7提供了的一个用于并行执行任务的框架， 是一个把大任务分割成若干个小任务，最终汇总每个小任务结果后得到大任务结果的框架。
我们再通过Fork和Join这两个单词来理解下Fork/Join框架，Fork就是把一个大任务切分为若干子任务并行的执行，Join就是合并这些子任务的执行结果，最后得到这个大任务的结果。比如计算1+2+。。＋10000，可以分割成10个子任务，每个子任务分别对1000个数进行求和，最终汇总这10个子任务的结果。Fork/Join的运行流程图如下：

2.工作窃取算法

工作窃取（work-stealing）算法是指某个线程从其他队列里窃取任务来执行。工作窃取的运行流程图如下：
那么为什么需要使用工作窃取算法呢？假如我们需要做一个比较大的任务，我们可以把这个任务分割为若干互不依赖的子任务，为了减少线程间的竞争，于是把这些子任务分别放到不同的队列里，并为每个队列创建一个单独的线程来执行队列里的任务，线程和队列一一对应，比如A线程负责处理A队列里的任务。但是有的线程会先把自己队列里的任务干完，而其他线程对应的队列里还有任务等待处理。干完活的线程与其等着，不如去帮其他线程干活，于是它就去其他线程的队列里窃取一个任务来执行。而在这时它们会访问同一个队列，所以为了减少窃取任务线程和被窃取任务线程之间的竞争，通常会使用双端队列，被窃取任务线程永远从双端队列的头部拿任务执行，而窃取任务的线程永远从双端队列的尾部拿任务执行。
工作窃取算法的优点是充分利用线程进行并行计算，并减少了线程间的竞争，其缺点是在某些情况下还是存在竞争，比如双端队列里只有一个任务时。并且消耗了更多的系统资源，比如创建多个线程和多个双端队列。

3、模拟实际业务代码对比性能差别

jdk1.7之后推出了Fork/Join框架，其原理个人理解为：递归多线程并发处理业务代码，以下为我模拟我们公司业务代码做的一个案例，性能可提升75%：

**下边这个类是模拟现有业务代码写的**

package NoForkJoin;

import forkJoinTest.Row;
import forkJoinTest.Student;

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

/**
 * @author liu_l
 * @Title: ServiceImp
 * @ProjectName workspace-idea
 * @Description: TODO
 * @date 2018/6/240:32
 */
public class ServiceImp {
    
    public static void main(String[] args) throws InterruptedException {
        long s0 = System.currentTimeMillis();
        //造业务数据
        List<Student> list = new ArrayList<Student>();
        for (int i = 0; i < 10000; i++) {
            Student student = new Student();
            student.setName("test1" + i);
            student.setSax("man");
            student.setTall((double) i);
            list.add(student);
        }
        //开始业务数据处理
        List<Row> rows = new ArrayList<Row>();
        for (int i = 0; i < 10000; i++) {
            Student student = list.get(i);
            //模拟一条业务数据处理需耗时1毫秒
            Thread.sleep(1);
            Row row = new Row();
            row.put("name", student.getName());
            row.put("sax", student.getSax());
            row.put("tall", student.getTall());
            rows.add(row);
        }
        System.out.println("共处理业务对象：" + rows.size() + "个");
        System.out.println("共耗时：" + (System.currentTimeMillis() - s0) + "毫秒");
    }
}

运行结果如图：

下面为采用fork/join框架来实现此功能：

student类：模拟业务对像

		package forkJoinTest;
		
		import java.io.Serializable;
		
		/**
		 * @author liu_l
		 * @Title: Student
		 * @ProjectName workspace-idea
		 * @Description: TODO
		 * @date 2018/6/2323:03
		 */
		public class Student implements Serializable {
		
		    private String name;
		
		    private Double tall;
		
		    private String sax;
		
		    public String getName() {
		        return name;
		    }
		
		    public void setName(String name) {
		        this.name = name;
		    }
		
		    public Double getTall() {
		        return tall;
		    }
		
		    public void setTall(Double tall) {
		        this.tall = tall;
		    }
		
		    public String getSax() {
		        return sax;
		    }
		
		    public void setSax(String sax) {
		        this.sax = sax;
		    }
		}

rows继承与HashMap，将业务对象组装为map格式：

		package forkJoinTest;
		
		import java.util.ArrayList;
		import java.util.concurrent.ConcurrentHashMap;
		
		/**
		 * @author liu_l
		 * @Title: Row
		 * @ProjectName workspace-idea
		 * @Description: TODO
		 * @date 2018/6/2323:06
		 */
		public class Row extends ConcurrentHashMap{
		
		    public Student Student;
		}

**重点：Fork/Join框架处理业务代码：**

		package forkJoinTest;

		import java.util.ArrayList;
		import java.util.List;
		import java.util.concurrent.RecursiveTask;
		
		/**
		 * @author liu_l
		 * @Title: ForkJoin
		 * @ProjectName workspace-idea
		 * @Description: TODO
		 * @date 2018/6/2323:09
		 */
		public class ForkJoinCode extends RecursiveTask<List<Row>>{
		
		    protected static int THREAD_HOLD = 50;
		    protected int start;//开始任务序号
		    protected int end;//结束任务序号
		    protected List<Student> datas;
		
		    /**
		     * @Description: TODO
		     * @param:
		     * @author liu-lei
		     * @date 2018/6/23 23:19
		     */
		    public static ForkJoinCode getInstance(int start, int end, List<Student> datas){
		        ForkJoinCode forkJoinCode = new ForkJoinCode();
		        forkJoinCode.start = start;
		        forkJoinCode.end = end;
		        forkJoinCode.datas = datas;
		        return forkJoinCode;
		    }
		
		    @Override
		    protected List<Row> compute() {
		        List<Row> rows = new ArrayList<Row>();
		        boolean canCompute = (end - start) <= THREAD_HOLD;
		        if(canCompute){
		            for(int i = start; i <= end; i++){
		                tranfromT2Row(rows, i);
		            }
		        }else{
		            int middle = (start + end)/2;
		            ForkJoinCode leftForkJoin = ForkJoinCode.getInstance(start, middle, datas);
		            ForkJoinCode rightForkJoin = ForkJoinCode.getInstance(middle+1, end, datas);
		            leftForkJoin.fork();
		            rightForkJoin.fork();
		            List<Row> lResult = leftForkJoin.join();
		            List<Row> rResult = rightForkJoin.join();
		            rows.addAll(lResult);
		            rows.addAll(rResult);
		        }
		        return rows;
		    }
		
		    /**
		     * @Description: 业务代码处理
		     * @param:
		     * @author liu-lei
		     * @date 2018/6/24 0:33
		     */
		    public void tranfromT2Row(List<Row> rows, int i){
		        Student student = datas.get(i);
		        Row row = new Row();
		        row.put("name", student.getName());
		        row.put("sax", student.getSax());
		        row.put("tall", student.getTall());
		        try {
		            //模拟业务数据处理需耗时5毫秒
		            Thread.sleep(3);
		        } catch (InterruptedException e) {
		            e.printStackTrace();
		        }
		        rows.add(row);
		    };
}

Service方法进行调用：

		package forkJoinTest;
		
		import java.util.ArrayList;
		import java.util.List;
		import java.util.concurrent.ExecutionException;
		import java.util.concurrent.ForkJoinPool;
		import java.util.concurrent.Future;
		
		/**
		 * @author liu_l
		 * @Title: ServiceImp
		 * @ProjectName workspace-idea
		 * @Description: TODO
		 * @date 2018/6/240:12
		 */
		public class ServiceImp {
		    public static void main(String[] args) throws ExecutionException, InterruptedException {
		        long s0 = System.currentTimeMillis();
		        //造业务数据
		        List<Student> list = new ArrayList<Student>();
		        for(int i = 0; i < 10000; i ++){
		            Student student = new Student();
		            student.setName("test1" + i);
		            student.setSax("man");
		            student.setTall((double)i);
		            list.add(student);
		        }
		        //开始业务数据处理
		        ForkJoinPool pool = new ForkJoinPool();
		        ForkJoinCode studentForkJoinCode = ForkJoinCode.getInstance(0, list.size()-1, list);
		        Future<List<Row>> result = pool.submit(studentForkJoinCode);
		        System.out.println("共处理业务对象：" + result.get().size() + "个");
		        showPoolStates(pool);
		        System.out.println("共耗时：" + (System.currentTimeMillis() - s0) + "毫秒");
		    }
		
		    /**
		     * @Description: 监控Fork/Join池相关方法
		     * @param:
		     * @author liu-lei
		     * @date 2018/6/24 0:43
		     */
		    private  static  void showPoolStates(ForkJoinPool pool){
		        System.out.println("*******************");
		        System.out.println("线程池的worker线程数量：" + pool.getPoolSize());
		        System.out.println("当前执行任务的线程数量：" + pool.getActiveThreadCount());
		        System.out.println("没有被阻塞正在工作的线程：" + pool.getRunningThreadCount());
		        System.out.println("已经提交给池还没有开始执行的任务数：" + pool.getQueuedSubmissionCount());
		        System.out.println("已经提交给池开始执行的任务数：" + pool.getQueuedTaskCount());
		        System.out.println("线程偷取任务数：" + pool.getStealCount());
		
		    }
		}

测试结果如下：

讲个结果对比性能提升了63%：