Java线程池-异步任务编排

1.初始化线程的4 种方式

1.继承 Thread

package com.atguigu.gulimall.mytest;
import org.junit.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class MytestApplicationTests {


    @Test
    public void test() {

        Thread1 thread1 = new Thread1();
        thread1.run();
    }

    /**
     * 继承Thread接口
     */
    public class Thread1 extends Thread{

        @Override
        public void run() {
            System.out.println("thread1运行开始");
            try {
                Thread.sleep(5000);//单位毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("thread1运行结束");
        }
    }

}

2.实现 Runnable 接口

package com.atguigu.gulimall.mytest;
import org.junit.Test;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
public class MytestApplicationTests {

    @Test
    public void test() {

        Thread2 thread2 = new Thread2();
        thread2.run();
    }
    

    /**
     * 实现Runnable接口
     */
    public class Thread2 implements Runnable{

        @Override
        public void run() {
            System.out.println("thread2运行开始");
            try {
                Thread.sleep(5000);//单位毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("thread2运行结束");
        }
    }
}

3.实现 Callable 接口

FutureTask可以拿到返回结果，可以处理异常
futureTask.get()阻塞等待整个线程执行完成，获取返回结果

package com.atguigu.gulimall.mytest;
import org.junit.Test;
import org.springframework.boot.test.context.SpringBootTest;

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

@SpringBootTest
public class MytestApplicationTests {

    @Test
    public void test() throws ExecutionException, InterruptedException {

        Callable01 callable01 = new Callable01();
        FutureTask<Integer> futureTask = new FutureTask<>(callable01);

        Thread thread = new Thread(futureTask);
        thread.start(); //启动线程
        Integer integer = futureTask.get();//等待线程返回结果之前, 下面的代码不会执行
        System.out.println(integer);
        System.out.println("任务完成");
    }



    /**
     *  实现Callable接口
     */
    public class Callable01 implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            System.out.println("thread3运行开始");
            try {
                Thread.sleep(5000);//单位毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("thread3运行结束");
            return 10;
        }
    }
}

4.线程池ExecutorService

package com.atguigu.gulimall.mytest;
import org.junit.Test;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.concurrent.*;

@SpringBootTest
public class MytestApplicationTests {

    @Test
    public void test() throws ExecutionException, InterruptedException {
        Callable01 callable01 = new Callable01();

        ExecutorService executorService = Executors.newFixedThreadPool(10);
        FutureTask<Integer> futureTask = (FutureTask<Integer>)executorService.submit(callable01);
        System.out.println("等待结果");
        System.out.println(futureTask.get());
        System.out.println("任务完成");
    }


    /**
     *  实现Callable接口
     */
    public class Callable01 implements Callable<Integer> {

        @Override
        public Integer call() throws Exception {
            System.out.println("thread3运行开始");
            try {
                Thread.sleep(5000);//单位毫秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("thread3运行结束");
            return 10;
        }
    }

}

2.线程池的7大参数

线程池工作流程图

• corePoolSize（必需）：核心线程数。默认情况下，核心线程会一直存活，但是当将
  allowCoreThreadTimeout 设置为 true 时，核心线程也会超时回收。

• maximumPoolSize（必需）：线程池所能容纳的最大线程数。当活跃线程数达到该数值后，后续的新任务将会阻塞。

• keepAliveTime（必需）：线程闲置超时时长。如果超过该时长，非核心线程就会被回收。如果将 allowCoreThreadTimeout 设置为 true 时，核心线程也会超时回收。

• unit（必需）：指定 keepAliveTime参数的时间单位。常用的有：TimeUnit.MILLISECONDS（毫秒）、TimeUnit.SECONDS（秒）、TimeUnit.MINUTES（分）。

• workQueue（必需）：任务队列。通过线程池的 execute() 方法提交的 Runnable对象将存储在该参数中。其采用阻塞队列实现。

• threadFactory（可选）：线程工厂。用于指定为线程池创建新线程的方式。

• handler（可选）：拒绝策略。当达到最大线程数时需要执行的饱和策略。

一个线程池 core 7； max 20 ，queue：50，100 并发进来怎么分配的?
先有 7 个能直接得到执行，接下来 50 个进入队列排队，在多开 13 个继续执行。现在 70 个 被安排上了。剩下 30 个默认拒绝策略。

3.常见的4 种线程池

• newCachedThreadPool 创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若 无可回收，则新建线程。

• newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

• newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

• newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行

4.CompletableFuture 异步编排

1.创建异步对象

CompletableFuture 提供了四个静态方法来创建一个异步操作。

1、runAsync都是没有返回结果的，supplyAsync都是可以获取返回结果的
2、可以传入自定义的线程池，否则就用默认的线程池；

package com.atguigu.gulimall.mytest.test;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class threadTest {

    public static ExecutorService executor = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //异步任务1
        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
            System.out.println("当前线程1：" + Thread.currentThread().getId());
            int i = 10 / 2;
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("运行结果1：" + i);
        }, executor);

        //异步任务2
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("当前线程2：" + Thread.currentThread().getId());
            int i = 10 / 2;
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("运行结果2：" + i);
            return i;
        }, executor);

        Integer res2 = (Integer) future2.get();
        System.out.println("res2="+res2);
    }

}

2.计算完成时回调方法

• whenComplete 可以处理正常和异常的计算结果，exceptionally 处理异常情况。
• whenComplete 和 whenCompleteAsync 的区别：
  whenComplete：是执行当前任务的线程执行继续执行whenComplete 的任务。 whenCompleteAsync：是执行把 whenCompleteAsync这个任务继续提交给线程池 来进行执行。
• 方法不以 Async 结尾，意味着 Action 使用相同的线程执行，而 Async 可能会使用其他线程
  执行（如果是使用相同的线程池，也可能会被同一个线程选中执行）

1.在 supplyAsync、runAsync执行完毕后还想做其他任务就可以使用链式调用whenComplete（是指当前任务的线程执行继续执行）、whenCompleteAsync（是重新提交到线程池进行执行），这两个可以接收到成功值或者异常信息，只能作为监听成功或失败。

package com.atguigu.gulimall.mytest.test;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class threadTest {

    public static ExecutorService executor = Executors.newFixedThreadPool(10);

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

        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            return "ok";
        }, executor).whenComplete((res,exception)->{
            System.out.println("结果是："+res+"异常是："+exception);
        });
        String res = future.get();
        System.out.println("线程返回结果:"+res);

    }

}

2.还可以链式调用exceptionally，可以获取到异常信息并且可以修改最终值.

package com.atguigu.gulimall.mytest.test;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class threadTest {

    public static ExecutorService executor = Executors.newFixedThreadPool(10);

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

        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            int i = 10/0; //模拟异常
            return "ok";
        }, executor).whenComplete((res,exception)->{
            System.out.println("结果是："+res+"异常是："+exception);
        }).exceptionally((exception)->{
            return "not ok";
        });
        String res = future.get();
        System.out.println("线程返回结果:"+res);

    }
}

3.handle 方法

handle方法可以接受两个参数（成功值，异常信息），返回一个参数（可以修改最终返回值），相当于方法执行后的处理

package com.atguigu.gulimall.mytest.test;

import io.swagger.models.auth.In;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class threadTest {

    public static ExecutorService executor = Executors.newFixedThreadPool(10);

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

        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            //int i = 10/0; //模拟异常
            return "ok";
        }, executor).handle((res, exception) -> {
            if (exception==null){
                System.out.println("结果是：" + res);
                return res;
            }else{
                System.out.println("异常是：" + exception);
                return "not ok";
            }
        });

        String res = future.get();
        System.out.println("线程返回结果:"+res);

    }
}

5.线程串行化方法

提示: 链式调用方法后不加Async是指当前任务的线程执行继续执行，加上Async是重新提交到线程池进行执行

1.thenRun、thenRunAsync

要上面的任务执行完毕后才开始执行此方法的后续操作，无返回结果。

package com.atguigu.gulimall.mytest.test;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class threadTest {

    public static ExecutorService executor = Executors.newFixedThreadPool(10);

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

        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            System.out.println("one");
            return "ok";
        },executor).thenRunAsync(()->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("执行后续操作。。。");
        },executor);
    }
}

2.thenAccept、thenAcceptAsync

有一个入参（消费处理结果），接收处理结果进行后续操作，无返回结果。

package com.atguigu.gulimall.mytest.test;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class threadTest {

    public static ExecutorService executor = Executors.newFixedThreadPool(10);

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

        CompletableFuture future = CompletableFuture.supplyAsync(() -> {
            System.out.println("one");
            return "ok";
        }, executor).thenAcceptAsync((res)->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("接收到结果："+res+"执行后续操作。。。");
        },executor);
    }
}

3.thenApply、thenApplyAsync

接收返回结果，并进行后续操作，并返回当前任务的返回值

package com.atguigu.gulimall.mytest.test;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class threadTest {

    public static ExecutorService executor = Executors.newFixedThreadPool(10);

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

        CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
            return "ok";
        }, executor).thenApplyAsync((res)->{
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("接收到结果："+res+"执行后续操作。。。");
            return "ok666";
        },executor);

        String res = future.get();
        System.out.println("线程返回结果:"+res);

    }
}

4.两任务组合 - 都要完成

两个任务必须都完成，触发该任务。

1.thenCombine、thenCombineAsync：组合两个futre的返回结果，并且返回当前任务的返回值

package com.atguigu.gulimall.mytest.test;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class threadTest {

    public static ExecutorService executor = Executors.newFixedThreadPool(10);

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

        CompletableFuture<Integer> supplyAsync1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务1执行完毕");
            return 10;
        }, executor);
        CompletableFuture<Integer> supplyAsync2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2执行完毕");
            return 20;
        }, executor);
        CompletableFuture<Integer> combineAsync = supplyAsync1.thenCombineAsync(supplyAsync2, (res1, res2) -> {
            System.out.println("结合任务1和任务2的结果计算出任务3，并返回");
            return res1+res2;
        }, executor);
        Integer res = combineAsync.get();
        System.out.println("结果:"+res);
    }
}

2.thenAcceptBoth、thenAcceptBothAsync：组合两个 future，获取两个 future 任务的返回结果，然后处理任务，没有返回值。

package com.atguigu.gulimall.mytest.test;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class threadTest {

    public static ExecutorService executor = Executors.newFixedThreadPool(10);

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

        CompletableFuture<Integer> supplyAsync1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务1执行完毕");
            return 10;
        }, executor);
        CompletableFuture<Integer> supplyAsync2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2执行完毕");
            return 20;
        }, executor);
        CompletableFuture<Void> acceptBothAsync = supplyAsync1.thenAcceptBothAsync(supplyAsync2, (res1, res2) -> {
            System.out.println("结合任务1和任务2的结果执行任务3，没有返回值！");
            System.out.println("res1+res2="+(res1+res2));
        }, executor);
    }
}

3.runAfterBoth、thenAfterBothAsync：组合两个futre，不需要返回结果，只需要处理两个Future后执行该任务。

package com.atguigu.gulimall.mytest.test;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class threadTest {

    public static ExecutorService executor = Executors.newFixedThreadPool(10);

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

        CompletableFuture<Integer> supplyAsync1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务1执行完毕");
            return 10;
        }, executor);
        CompletableFuture<Integer> supplyAsync2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2执行完毕");
            return 20;
        }, executor);

        CompletableFuture<Void> afterBothAsync = supplyAsync1.runAfterBothAsync(supplyAsync2, () -> {
            System.out.println("任务1和任务2执行完执行任务3.没有返回值！");
        }, executor);
    }
}

5.两任务组合 - 一个完成

1.applyToEitherAsync、applyToEither: 两个任务有一个执行完成，获取它的返回值，处理任务并有新的返回值。

package com.atguigu.gulimall.mytest.test;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class threadTest {

    public static ExecutorService executor = Executors.newFixedThreadPool(10);

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

        CompletableFuture<Integer> supplyAsync1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务1执行完毕");
            return 10;
        }, executor);
        CompletableFuture<Integer> supplyAsync2 = CompletableFuture.supplyAsync(() -> {
            System.out.println("任务2执行完毕");
            return 20;
        }, executor);

        supplyAsync1.applyToEitherAsync(supplyAsync2,(res)->{
            System.out.println("res="+res);
            System.out.println("只要有一个完成就接收值，处理并返回值！");
            return 3;
        },executor);
    }
}

2.acceptEitherAsync、acceptEither：两个任务有一个执行完成，获取它的返回值，处理任务，没有新的返回值。

supplyAsync1.acceptEitherAsync(supplyAsync2,(res)->{
            System.out.println("只要有一个完成就接收值，处理不能返回值！");
        },executor);

3.runAfterEitherAsync、runAfterEither：两个任务有一个执行完成，不需要获取 future 的结果，处理任务，也没有返回值。

supplyAsync1.runAfterEitherAsync(supplyAsync2,()->{
            System.out.println("只要有一个完成不接受值，处直接理不能返回值！");
        },executor);

6.多任务组合

1.allOf：等待所有任务完成,没有返回值

package com.atguigu.gulimall.mytest.test;

import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class threadTest {

    public static ExecutorService executor = Executors.newFixedThreadPool(10);

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

        CompletableFuture<Integer> supplyAsync1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务1执行完毕");
            return 10;
        }, executor);
        CompletableFuture<Integer> supplyAsync2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(6000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务2执行完毕");
            return 20;
        }, executor);

        CompletableFuture<Integer> supplyAsync3 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务3执行完毕");
            return 30;
        }, executor);

        CompletableFuture<Void> all = CompletableFuture.allOf(supplyAsync1, supplyAsync2, supplyAsync3);
        System.out.println("ok1");
        all.get(); //阻塞,等待所有任务完成才执行后续代码
        System.out.println("ok2");

    }
}

2.anyOf：只要有一个任务完成, 可以有返回值

package com.atguigu.gulimall.mytest.test;


import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class threadTest {

    public static ExecutorService executor = Executors.newFixedThreadPool(10);

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

        CompletableFuture<Integer> supplyAsync1 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务1执行完毕");
            return 10;
        }, executor);
        CompletableFuture<Integer> supplyAsync2 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(6000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务2执行完毕");
            return 20;
        }, executor);

        CompletableFuture<Integer> supplyAsync3 = CompletableFuture.supplyAsync(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("任务3执行完毕");
            return 30;
        }, executor);

        CompletableFuture<Object> all = CompletableFuture.anyOf(supplyAsync1, supplyAsync2, supplyAsync3);
        System.out.println("ok1");
        Integer res = (Integer) all.get(); //阻塞,等待有一个任务完成才执行后续代码
        System.out.println("res="+res);
        System.out.println("ok2");

    }
}