Java异步的2种方式分析

我会带着你远行 2023-02-17 02:32 14阅读 0赞

**场景**

假设在web环境下有一个线程A需要10分钟后调用操作B。好在只要调用就可以不需要知道B的返回结果。

这种场景下实际上可以通过发送延迟消息队列来完成，A执行时发送一个延迟消息队列，它就可以去干别的事情了，这是安全可靠的做法。但是这个操作有点重，延迟消息队列是有成本的，包含资源成本和开发维护成本。

更省事的做法是通过线程sleep来做，但是这时候要注意了，线程sleep虽然让出了cpu，但是线程资源并没有释放。在web服务器比如tomcat、jetty这些，线程池是有固定大小的，默认是150。一个线程sleep10分钟，很可能一会线程池就打满了。

这时候可以通过异步来做，但是需要注意的是有两点。第一，有些异步操作虽然是异步的，但是主线程要等待其返回结果。对于web服务器来说，异步没有返回结果之前，它也是不能释放线程的，所以对于sleep10分钟这个操作来说同步异步区别不大。第二，如果频繁创建线程，每个线程都是消耗资源的，每个sleep10分钟，线程数过多，会造成内存溢出等问题。

其实使用异步还存在第三个问题，就是一旦进程停止，异步线程并没有执行完也终止了，会导致需要的操作没有被保证执行。但是这个不是本文考虑的内容，为了避免前面两个问题，我们来分析一下用哪种异步方式更为合适。

**分析**

**spring的@Async注解**

先来实验一下：

![format_png][]

注意：使用spring boot需要在程序启动类添加@EnableAsync注解，所有使用spring aop代理的功能类都需要响应的注解才能代理。

先使用标准用法，所谓标准用法是@Async注解的异步是带返回值的，那我们就将这个返回值作为结果返回。

**实验1**

在spring web环境下创建一个接受async的请求线程

@RestController
    public class ThreadController {
        @Resource
        private AsyncService asyncService;
    
        @GetMapping("/async")
        public String sync() throws Exception {

System.out.println("主线程开始" + Thread.currentThread());
            Future<String> future = asyncService.async();
            System.out.println("主线程结束" + future.get());
            return "异步线程OK";

}
    }

这个线程会调用异步线程

@Async
    public Future<String> async() {
        System.out.println("异步线程开始" + Thread.currentThread());
        try {
            Thread.sleep(10 * 60 * 1000L);
        } catch (Exception e) {
    
        }
        System.out.println("异步线程结束");
        return new AsyncResult<String>("异步结果返回OK");
    }
    运行结果

![format_png 1][]

从上面运行结果可知，运行到future.get的地方会阻塞，等待异步线程返回结果。

**实验2**

那我们来实验一下，如果不需要future.get是不是有可以直接返回，不阻塞主线程：

在spring web环境下创建一个接受async的请求线程

@RestController
    public class ThreadController {
        @Resource
        private AsyncService asyncService;
    
        @GetMapping("/async")
        public String async() {

System.out.println("主线程开始" + Thread.currentThread());

asyncService.async();
            System.out.println("主线程结束");
            return "OK";
        }
    }

这个线程会调用异步线程
    @Service
    public class AsyncService {
        @Async
        public void async() {

System.out.println("异步线程开始" + Thread.currentThread());

try {
                Thread.sleep(10 * 60 * 1000L);
            } catch (Exception e) {
    
            }
            System.out.println("异步线程结束");
        }
    }
    运行结果

![format_png 2][]

从上面运行结果可知，由于不需要返回结果，所以真正意义上实现了异步。

**jdk8的CompletableFuture.supplyAsync**

**实验1**

我希望可以通过supplyAsync来实现上面使用@Aysnc的实验2的效果。因为代码改动很少，我就不再贴了，只是将@Aysnc注解去掉，调用的地方使用

CompletableFuture.supplyAsync(() -> asyncService.async());

运行结果

![format_png 3][]

可以看到效果与使用@Aysnc注解完全一致。我担心的是线程过多，会不会引起资源过度消耗。开启50万个异步线程试试。

**实验2**

先启动程序，并不调用接口，通过top命令查看资源情况

![format_png 4][]

调度接口执行后查看资源情况如下，资源占用并没有增多，并且通过打印可看到这个异步操作有池化处理。

![format_png 5][]

我还是担心，那最终这些异步任务会不会被丢弃，导致部分任务没有执行呢？

我先等了十分钟看到任务继续执行

![format_png 6][]

狂点几下，看到top命令界面里，除了线程数有增加，其他基本没有变化。

![format_png 7][]

**实验3**

还不放心，那我们来改造一下试试。看看最终任务是不是都执行完了。改造方法就是在AsyncService里增加计数器，sleep时间改成1s。

@Service
    public class AsyncService {
        static AtomicInteger a = new AtomicInteger();
    
        public Future<String> async() {
            System.out.println("异步线程开始" + Thread.currentThread());
            try {
                Thread.sleep(1000L);
            } catch (Exception e) {
    
            }
            System.out.println("异步线程结束" + a.addAndGet(1));
            return new AsyncResult<String>("异步结果返回OK");
        }
    }
    运行了一段时间之后可以看到1w多次了，还在跑。
    我用计算器算了一下跑完50w次需要5天多，我就不等了。

![format_png 8][]

这里面要注意的是因为不关心返回值，所以将CompletableFuture.supplyAsync换成CompletableFuture.runAsync更地道些。

**总结**

分享这个简单的两种异步使用方式，目的是展示我在平时编码的时候的一种心态。《程序员修炼之道》里说：「不要假定，要证明」。对程序员来说没有什么可以想当然的，需要有理论之后实践出真知。这样一种编程习惯才能写出可维护性好，不被bug天天追着跑的代码。

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8ydGs1aWFuSXRSbDlWMklBQ2liOVlzZVhGRUprbDVacVU1blJCZGRoTzdESGFaaWNJckFkQ0liZ29yWmx4RlRkeWtkTXZYelpod2tydzJ6bWlialQySlJLMlEvNjQw?x-oss-process=image/format,png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8ydGs1aWFuSXRSbDlWMklBQ2liOVlzZVhGRUprbDVacVU1YXI2UXlrMHE3ZnpzaWNwY1Y2aFhxcmlhQlRpY3lpYkJFcklTWGMxdEJkNmlicG1WeUUxSjloeU4xTHcvNjQw?x-oss-process=image/format,png
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8ydGs1aWFuSXRSbDlWMklBQ2liOVlzZVhGRUprbDVacVU1ZmJvUks2aG1CaWFMUGhhbUh2R2NJbXdTVjJmbTFWaEZaZ0hzZzkyVTFkN0NrMVNaeXZBN0dMZy82NDA?x-oss-process=image/format,png
[format_png 3]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8ydGs1aWFuSXRSbDlWMklBQ2liOVlzZVhGRUprbDVacVU1dUxjd2tCTWlheEVpY2dhZzFxck8yZG5sWENQcExtWnA4aWJpYzFFM3pxQVRscnY2M1Y4YmhpYk9ubmcvNjQw?x-oss-process=image/format,png
[format_png 4]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8ydGs1aWFuSXRSbDlWMklBQ2liOVlzZVhGRUprbDVacVU1Q0k2b0xEc0tzNXI0UWhocVlCU1h0NUIzdXUwRVBxaWEwNlA1ckxDSUg4ZzJMc2lhcFBob2xndlEvNjQw?x-oss-process=image/format,png
[format_png 5]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8ydGs1aWFuSXRSbDlWMklBQ2liOVlzZVhGRUprbDVacVU1Tno1bThUc1BUMTNtT0h1enBrTlI2d2FYZDQxVm1CRVVHSzJkbVVnRnZuc0VIVWNORFJyYVF3LzY0MA?x-oss-process=image/format,png
[format_png 6]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8ydGs1aWFuSXRSbDlWMklBQ2liOVlzZVhGRUprbDVacVU1YTkxWlpkSUtVNTVLVlhTc1FzS242VHdvU3VvSmpFR1dmeUwzbVBXcE92QzRaeGVYblhuWGV3LzY0MA?x-oss-process=image/format,png
[format_png 7]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8ydGs1aWFuSXRSbDlWMklBQ2liOVlzZVhGRUprbDVacVU1UmY4cXlQRHhnM3Zvc0VpYWVvaWFYOXk2VzA2dTdsY0NCM2FlSFZyUzdFNTJBakVPaWFnTENPa3p3LzY0MA?x-oss-process=image/format,png
[format_png 8]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy8ydGs1aWFuSXRSbDlWMklBQ2liOVlzZVhGRUprbDVacVU1OW42dGtXTkR6QkVvWDhmbEF1b3doMTBEMTNNM0xPUWFSMzU2WGVIdFA1NVVBUGc4UVFaRjVnLzY0MA?x-oss-process=image/format,png