java异步编程

java异步调用

定义

​ Java异步调用是指在调用某个方法时，不需要等待该方法执行完毕才能继续执行下面的代码，而是通过多线程或回调函数等方式，让该方法在后台执行，同时允许程序继续执行下面的代码。这种方式可以提高程序的并发性和响应速度，特别是在处理大量数据或需要等待外部资源响应的情况下，可以避免程序阻塞或等待时间过长的问题。

应用场景

1. 处理大量的并发请求 当应用程序需要处理大量的并发请求时，Java异步调用可以提高应用程序的性能和响应能力。例如，当应用程序需要处理大量的HTTP请求时，可以使用Java异步调用来处理这些请求，以避免阻塞应用程序。
2. 处理耗时的操作 当应用程序需要执行一些耗时的操作时，Java异步调用可以让应用程序在执行这些操作时不会被阻塞。例如，当应用程序需要执行一些数据库操作时，可以使用Java异步调用来执行这些操作，以避免阻塞应用程序。
3. 处理异步事件 当应用程序需要处理异步事件时，Java异步调用可以让应用程序更方便地处理这些事件。例如，当应用程序需要处理一些异步消息时，可以使用Java异步调用来处理这些消息，以避免阻塞应用程序。

实现方式

1、手动显示创建新线程

private static List<Integer> list = Lists.newArrayList(1,2,3,4);
public static void main(String[] args) {
    for (Integer i : list) {
        if (i == 2){
            new Thread(() -> {

                System.out.println("异步线程 =====> 开始 =====> " + System.currentTimeMillis());
                try{
                    Thread.sleep(5000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println("异步线程 =====> 结束 =====> " + System.currentTimeMillis());
            }).start();
        }
        System.out.println("i的值为：" + i);
    }
}

输出结果

2、使用线程池创建新线程

private static List<Integer> list = Lists.newArrayList(1,2,3,4);
public static void main(String[] args) {
    for (Integer i : list) {
        if (i == 2){
            ExecutorService executorService = Executors.newSingleThreadExecutor();
            executorService.submit(()->{
                System.out.println("异步线程 =====> 开始 =====> " + System.currentTimeMillis());
                try{
                    Thread.sleep(5000);
                }catch (InterruptedException e){
                    e.printStackTrace();
                }
                System.out.println("异步线程 =====> 结束 =====> " + System.currentTimeMillis());
            });
            // 回收线程池
            executorService.shutdown();
        }
        System.out.println("i 的值为：" + i);
    }
}

3、CompletableFuture的runAsync方法

private static List<Integer> list = Lists.newArrayList(1,2,3,4);
    @Test
    public void mainThread() throws Exception{
        for (Integer i : list) {
            if (i == 2){
                // 创建线程池
                ThreadPoolExecutor executorService = new ThreadPoolExecutor(5, 10, 100, TimeUnit.SECONDS,new LinkedBlockingQueue<>(10));
                CompletableFuture.runAsync(() ->{
                    System.out.println("异步线程 =====> 开始 =====> " + System.currentTimeMillis());
                    try{
                        Thread.sleep(5000);
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                    System.out.println("异步线程 =====> 结束 =====> " + System.currentTimeMillis());
                },executorService);
                executorService.shutdown(); // 回收线程池
            }
            System.out.println("i的值为：" + i);
        }
        Thread.sleep(10000);
    }

4、使用@Async 注解

1、启动SpringBoot项目，加上 @EnableAsync 注解

@EnableAsync
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class);
    }

}

2、建立Controller类

@Slf4j
@RestController("/async")
public class AsyncController {
    @Autowired
    AsyncService asyncService;
    @GetMapping("/test")
    public String test() {
        asyncService.asyncTask();
        log.info("main task flag");
        return "main task finish";
    }
}

3、Service

@Service
@Slf4j
public class AsyncService {
    @Async("taskExecutor")
    public void asyncTask() {
        log.info("异步线程 =====> 开始 =====> " + System.currentTimeMillis());
        try{
            Thread.sleep(5000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        log.info("异步线程 =====> 结束 =====> " + System.currentTimeMillis());
    }
}

启动springboot程序后，调用接口，观看日志