异步task

FutureTask

• 作为线程：实现Runnable接口
• 异步处理：实现了Future接口
• 有返回值：构造注入了Callable< T>，提供了Callable功能
  

package threads.juc;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @author ：suguohu
 * @date ：Created in 2023/3/16 17:54
 */
public class FutureDemo {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        FutureTask<String> futureTask = new FutureTask<String>(
                new Callable<String>() {
                    @Override
                    public String call() throws Exception {
                        System.out.println("线程：" + Thread.currentThread().getName());
                        System.out.println("call Thread");
                        return String.valueOf(System.currentTimeMillis());
                    }
                }
        );
        new Thread(futureTask).start();
        System.out.println("主线程"+System.currentTimeMillis());
        // get会阻塞
        String string = futureTask.get();
        System.out.println(System.currentTimeMillis() - Long.parseLong(string));
        System.out.println(string);
    }
}

ForkJoinTask

在JDK1.7,ForkJoin，并行执行任务！提高效率，大数据量!
大数据：Map Reduce（把大任务拆分为小任务）

就是在必要的情况下，将一个大任务进行拆分（fork）成若干个小任务，再将一个个的小任务运算的结果进行join汇总。

工作窃取

工作窃取模式（work-stealing）：当执行的新任务时它可以将拆分成更小的任务执行，并将小任务加到线程队列中，当没有任务执行时，再从一个随机线程的队列中偷一个并把它放在自己的队列中。相对于一般的线程池实现，fork/join框架的优势体现在对其中包含的任务的处理方式上，在一般的线程池中，如果一个线程正在执行的任务由于某些原因无法继续运行那么该线程回处于等待状态。而在fork/join框架实现中，如果某个子问题由于等待另一个子问题的完成而无法继续运行。那么处理该子问题的线程会主动寻找其他尚未运行的子问题（窃取过来）来执行，这种方式减少了线程的等待时间，提高了性能。

RecursiveTask：有返回值的递归任务
RecursiveAction：无返回值的递归事件

package threads.juc;

import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;

/**
 * @author ：suguohu
 * @date ：Created in 2023/3/17 16:30
 * @description ：
 * @modified By：suguohu
 * @version: 1.0.0
 */
public class ForkJoinTaskDemo extends RecursiveTask<Long> {

    private Long start;
    private Long end;
    // 临界值
    private Long temp = 10000L;

    public ForkJoinTaskDemo(Long start, Long end) {
        this.start = start;
        this.end = end;
    }

    @Override
    protected Long compute() {
        if ((end - start) < temp) {
            Long sum = 0L;
            for (long i = start; i <= end; i++) {
                sum += i;
            }
            return sum;
        }else {
            // 中间值
            long middle = (start + end) / 2;
            ForkJoinTaskDemo taskDemo = new ForkJoinTaskDemo(start, middle);
            // 拆分任务，把任务压入线程队列
            taskDemo.fork();
            ForkJoinTaskDemo taskDemo1 = new ForkJoinTaskDemo(middle + 1, end);
            taskDemo1.fork();
            return taskDemo.join() + taskDemo1.join();
        }
    }
}

package threads.juc;

import jdk.swing.interop.SwingInterOpUtils;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ForkJoinPool;
import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.RecursiveTask;
import java.util.stream.LongStream;

/**
 * @author ：suguohu
 * @date ：Created in 2023/3/17 16:30
 * @description ：
 * @modified By：suguohu
 * @version: 1.0.0
 */
public class ForkJoinTaskDemoTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        test1();
        test2();
        test3();
    }

    private static final Long MAX_VALUE = 10_0000_0000L;

    public static void test1() {
        Long sum = 0L;
        long start = System.currentTimeMillis();
        for (Long i = 1L; i <= MAX_VALUE; i++) {
            sum += i;
        }
        long end = System.currentTimeMillis();
        System.out.println("sum=" + sum + "时间：" + (end - start));
    }

    public static void test2() throws ExecutionException, InterruptedException {
        long start = System.currentTimeMillis();
        ForkJoinPool forkJoinPool = new ForkJoinPool();
        ForkJoinTask<Long> task = new ForkJoinTaskDemo(0L, MAX_VALUE);
        // 提交任务
        ForkJoinTask<Long> submit = forkJoinPool.submit(task);
        Long sum = submit.get();
        Long end = System.currentTimeMillis();
        System.out.println("sum=" + sum + "时间：" + (end - start));
    }

    public static void test3() {
        long start = System.currentTimeMillis();
        // Stream并行流
        long sum = LongStream.rangeClosed(0L, MAX_VALUE).parallel().reduce(0, Long::sum);
        long end = System.currentTimeMillis();
        System.out.println("sum=" + sum + "时间：" + (end - start));

    }

}