【Java基础】线程笔记—— Fork/Join

JDK7的Fork/Join

思想：化繁为简、分而治之、递归的分解和合并，直到任务小到可以接收的程度
目的：并行执行任务的框架

Future任务机制和FutureTask

Future就是对具体的Runnable和Callable的执行结果进行取消、查询是否完成、获取结果
1.判断任务是否完成
2.是否中断任务
3.能够获取任务执行结果
FutureTask是Future的实现类
FutureTask实现RunnableFuture接口（继承Runnable和Future）
应用场景：需要统计各种类型报表记录结果（拆分成多个小线程进行模块运算，然后将结果合并作为大报表呈现结果）

Future相关

RecursiveAction 用于没有返回结果的任务
RecursiveTask 用于返回结果的任务
execute() 异步执行任务
invoke() 指定指定的任务，等待完成，返回结果
submit() 异步执行指定的任务，并立即返回Future对象

Future原理

特殊的线程池框架（分叉/结合）
ForkJoinPool利用了工作窃取类算法，使得空闲线程能够主动分担从别的线程分解的主任务

计算最大并发量

根据请求大小和CPU运行机制和执行时间
（响应大小/内存大小、宽带/请求大小对应）
单台IO运行时间、CPU切换时间、程序执行时间、有没有数据库处理的等待
通过日志监控，查看用户访问哪些请求、请求哪些参数（找另一个和服务器一样的配置机器做压力测试）

Fork/Join优缺点

• 优点
  
  1. 充分实现并发程序任务拆分
  2. 简化编程
  3. 着重划分任务和组合中间结果
• 缺点
  
  1. 拆分对象不宜过多，容易造成内存溢出

Fork/Join应用场景

树形数据结构处理和遍历

api

fork() //异步执行任务
join() //计算完成后返回结果
RecursiveTask //用于无返回结果的任务
RecursiveAction //用于有返回结果的任务
ForkJoinPool //实现Executor接口
//三个调度子方法
execute() //异步执行
invoke() //等待完成，返回结果
submit() //异步执行execute任务，并立即返回Future对象

FutureTask

public class FutureTaskDemo {

    public static void main(String[] args) throws InterruptedException, ExecutionException {

        SonTask sonTask = new SonTask("线程2");
        FutureTask<String> task1 = new FutureTask<>(sonTask);
        new Thread(task1).start();
        System.out.println(task1.get()); //获取结果

        FutureTask<Integer> task2 = new FutureTask<Integer>(new MySun(),2);
        new Thread(task2).start();
        System.out.println("result_"+task2.get());
    }

}

---

public class SonTask implements Callable<String> {

    private String name = "";

    SonTask(String name) {
        this.name = name;
    }

    @Override
    public String call() throws Exception {
        Thread.sleep(1000L);
        System.out.println(name + "计算完成");
        return "result_1";
    }

}

---

public class MySun implements Runnable {

    @Override
    public void run() {

        try {
            Thread.sleep(500L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("线程2处理完成");
    }

}

console

result_1
result_2

Fork/Join

public class CountTask extends RecursiveTask<Integer>{

    private static final long serialVersionUID = 2148758397044775857L;

    private static int splitSize = 2; 
    private int start , end; 


    public CountTask(int start, int end) {
        this.start = start;
        this.end = end;
    }



    @Override
    protected Integer compute() {
        int sum = 0;
        //如果任务不需要拆分就开始计算
        boolean isSplit =  (end - start) <= splitSize;
        if(isSplit){
            for (int i = start; i <= end; i++) {
                sum += i;
            }
        }else{ //拆分成2个子任务
            int middle = (start + end) / 2;
            CountTask oneTask = new CountTask(start, middle);
            CountTask twoTask = new CountTask(middle+1, end);
            oneTask.fork();//开始执行
            twoTask.fork();

            //获得第一个子任务结果
            int oneResult = oneTask.join();
            int twoResult = twoTask.join();

            sum = oneResult + twoResult;
        }
        return sum;
    }

}

运行

public class FockJoinDemo {

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        ForkJoinPool pool = new ForkJoinPool();
        CountTask count1 = new CountTask(1, 5);

        Future<Integer> res1 = pool.submit(count1);
        System.out.println("1-5结果: "+res1.get());

        CountTask count2 = new CountTask(1, 100);
        Future<Integer> res2 = pool.submit(count2);
        System.out.println("1-100结果："+res2.get());

        System.out.println("=============Fock/Join监控===============");

        System.out.println(pool.getActiveThreadCount());
        System.out.println(pool.getQueuedTaskCount());
        System.out.println(pool.getQueuedSubmissionCount());
    }

}

console

1-5结果: 15
1-100结果：5050
=============Fock/Join监控===============
1
0
0

IBM_Fork/Join分析