jdk1.7推出的Fork/Join提高业务代码处理性能

jdk1.7推出的Fork/Join提高业务代码处理性能

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%：