Java异步编程介绍与@Async注解的使用

最新推荐文章于 2024-08-13 15:49:12 发布
最新推荐文章于 2024-08-13 15:49:12 发布
阅读量3.5k 收藏 16
点赞数 11
分类专栏： Spring 文章标签： java 多线程 spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44360895/article/details/112451841
版权

在开发经常遇到类似这样一种场景：订单支付成功回调中，修改了本地订单记录的状态后，有时需要把状态更新到第三方系统。这时候大多数情况下不需要等待与第三方系统交互的结果就可以直接返回，针对这种场景就可以采用异步编程来实现。

1、同步编程与异步编程的区别

1.1、同步编程

同步是指各个方法在同一线程内按顺序执行，即下一个方法要等待上一个方法执行完成后才开始执行。调用者需要等待所有方法都执行完后才返回。
示例代码如下：

1.1.1、同步方法

@Service
public class AsyncService {

    public void method1() throws InterruptedException {
        String name = Thread.currentThread().getName();
        System.out.println("线程" + name + "执行方法1，需要3s……");
        TimeUnit.SECONDS.sleep(3);
    }

    public void method2() throws InterruptedException {
        String name = Thread.currentThread().getName();
        System.out.println("线程" + name + "执行方法2，需要2s……");
        TimeUnit.SECONDS.sleep(2);
    }

    public void method3() throws InterruptedException {
        String name = Thread.currentThread().getName();
        System.out.println("线程" + name + "执行方法3，需要2s……");
        TimeUnit.SECONDS.sleep(2);
    }
}

1.1.2、调用者

@RestController
@RequestMapping("/async")
public class AsyncController {

    @Autowired
    private AsyncService asyncService;

    @RequestMapping("/test1")
    public String test1()throws Exception{
        long start = System.currentTimeMillis();
        asyncService.method1();
        asyncService.method2();
        asyncService.method3();
        long end = System.currentTimeMillis();
        String s = "共消耗：" + (end - start) / 1000 + "s";
        System.out.println(s);
        return s;
    }
}

print: 
线程http-nio-8080-exec-1执行方法1，需要3s……
线程http-nio-8080-exec-1执行方法2，需要2s……
线程http-nio-8080-exec-1执行方法3，需要2s……
共消耗：7s

7s后浏览器输出：
在这里插入图片描述

1.2、异步编程

异步是指方法另起独立线程执行，即调用者只是发送了调用的指令，无需等待被调用的方法完全执行完毕就返回结果。
示例代码如下：

1.2.1、创建一个简单的线程池

package com.demo.async;

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

public class PoolExecutorService {

    private static ExecutorService pool;

    public static ExecutorService getExecutorService(){
        if(pool == null){
            pool = Executors.newFixedThreadPool(10);//线程池大小设置10
        }
        return pool;
    }
}

1.2.2、调用者

此处还是继续用上面1.1.1的同步方法，只是手动起独立线程调用。

@RestController
@RequestMapping("/async")
public class AsyncController {

    @Autowired
    private AsyncService asyncService;

    @RequestMapping("/test2")
    public String test2()throws Exception{
        // 创建线程池
        ExecutorService pool = PoolExecutorService.getExecutorService();
        long start = System.currentTimeMillis();
        pool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    asyncService.method1();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        pool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    asyncService.method2();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        pool.execute(new Runnable() {
            @Override
            public void run() {
                try {
                    asyncService.method3();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
        long end = System.currentTimeMillis();
        String s = "共消耗：" + (end - start) / 1000 + "s";
        System.out.println(s);
        return s;
    }  
}

print: 
线程pool-1-thread-1执行方法1，需要3s……
线程pool-1-thread-2执行方法2，需要2s……
共消耗：0s
线程pool-1-thread-3执行方法3，需要2s……

无需等待，浏览器立即输出如下：
在这里插入图片描述

2、@Async注解

在spring 3.x之后，提供了@Async注解，被@Async标注的方法，称为异步方法，这些方法在执行时，Spring会为它们自动创建独立线程，而不用像上面1.2.2一样手动起线程。

2.1、启用@Async

2.1.1、Sprint Boot项目

若是Sprint Boot项目，在启动类上加@EnableAsync注解即可。

package com.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

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

2.1.2、Java-web项目

若是Java-web项目则在ApplicationContext.xml中写如下配置：

<task:executor id="myexecutor" pool-size="10" />
<task:annotation-driven executor="myexecutor"/>

2.2、异步方法

在方法上加@Async注解

@Service
public class AsyncService {

    @Async
    public void asyncMethod1() throws InterruptedException {
        String name = Thread.currentThread().getName();
        System.out.println("线程" + name + "执行异步方法1，需要3s……");
        TimeUnit.SECONDS.sleep(3);
    }

    @Async
    public void asyncMethod2() throws InterruptedException {
        String name = Thread.currentThread().getName();
        System.out.println("线程" + name + "执行异步方法2，需要3s……");
        TimeUnit.SECONDS.sleep(3);
    }
}

2.3、调用者

在调用者中和正常方法一样地调用，不必手动另起独立线程。

@RestController
@RequestMapping("/async")
public class AsyncController {

    @Autowired
    private AsyncService asyncService;

    @RequestMapping("/test3")
    public String test3()throws Exception{
        long start = System.currentTimeMillis();
        asyncService.asyncMethod1();
        asyncService.asyncMethod2();
        long end = System.currentTimeMillis();
        String s = "共消耗：" + (end - start) / 1000 + "s";
        System.out.println(s);
        return s;
    }
}

print: 
共消耗：0s
线程task-2执行异步方法2，需要3s……
线程task-1执行异步方法1，需要3s……

浏览器输出：
在这里插入图片描述

2.4、有返回值调用

@Async在大多数业务场景都是用于无返回值的调用，当需要获取异步方法返回值时，可以返回AsyncResult类型的结果。

2.4.1、异步方法

@Service
public class AsyncService {

    @Async
    public Future<String> asyncMethod3() throws InterruptedException {
        System.out.println("执行异步方法3，需要3s……");
        TimeUnit.SECONDS.sleep(3);
        return new AsyncResult<>("异步方法3执行完成！");
    }
}

2.4.2、调用者

@RestController
@RequestMapping("/async")
public class AsyncController {

    @Autowired
    private AsyncService asyncService;

    @RequestMapping("/test4")
    public String test4()throws Exception{
        Future<String> future = asyncService.asyncMethod3();
        String s = "";
        while (true){//这里使用了循环判断，等待获取结果信息
            if (future.isDone()){//判断是否执行完毕
                s = future.get();
                break;
            }
            System.out.println("Continue doing something else...");
            Thread.sleep(1000);
        }
        return s;
    }
}

print: 
Continue doing something else...
执行异步方法3，需要3s……
Continue doing something else...
Continue doing something else...
Continue doing something else...

等待3s后，浏览器输出：
在这里插入图片描述

Alex·Guangzhou
关注
专栏目录
Java异步注解@Async详解
Jack章臣的博客
11-10 2万+
再查看一下initializeExecutor抽象方法的具体实现类，其中有一个就是ThreadPoolTaskExecutor类，查看它的initializeExecutor方法，使用的就是ThreadPoolExecutor。在需要异步执行的方法上加入@Async注解，并指定使用的线程池，当然可以不指定，直接写@Async。的名称，也就是不自定义线程池，@Async是有默认线程池的，使用的是Spring默认的线程池SimpleAsyncTaskExecutor。配置文件中的线程池核心线程数为何配置为。
SpringBoot @Scheduled注解使用: 同步/异步同一任务及多任务并发执行
热门推荐
Demo_Liu的博客
12-29 2万+
本文将介绍@Scheduled注解使用过程中: 1.1 同一任务的同步执行(下次任务执行将在本次任务执行完毕后的下一次配置时间开始) 1.2 同一任务的异步执行(下次任务将在下一个配置时间开始,不等待当前任务执行完毕) 2.1多任务并发执行 首先,要想使用@Scheduled注解,首先要在启动类上添加注解@EnableScheduling @SpringBootApplica...
关于程序运行时的数据结构
talent_CYJ
04-29 2320
对于可执行文件，它包含了许多的段，例如(数据段，文本段，BSS段等)，它们是二进制文件中简单的区域，里面保存了和某种特定类型(如符号表条目)相关的所有信息。 对于一个源文件，哪些地方会放到哪个段，如下图： 可得知，程序代码是存放在文本段，初始化的全局变量和静态变量是存放到数据段中的，而没有初始化的全局变量和静态变量则是存放到BBS，运行时所需要的BSS段的大小记录在目标文件中，但BSS段并
Java注解详解：@Async异步
最新发布
m0_48038376的博客
08-13 1048
是 Spring 框架里的一个小工具，能让你的方法在后台偷偷跑起来，不影响主线程的工作。这个方法特别适合用来处理那些不需要立即给用户反馈的任务，比如发个邮件啊，处理个大文件啥的。通过这个机制，Spring 可以非常方便地处理大量并发任务，提升应用的性能和响应速度。你可以通过配置线程池来管理这些异步任务的执行，比如设置线程的数量、任务队列的大小等。注解，Spring 会创建一个代理对象来处理这个方法的调用。所以，异步执行的效果其实是由后台的线程池来实现的。，它会为每个任务创建一个新的线程。
JVM - 整体结构
Javaer`s blog
10-25 137
1. 整体结构 2. JVM的生命周期 虚拟机的启动 Java虚拟机的启动是通过引导类加载器创建一个初始类来完成的，这个类是由虚拟机的具体实现指定的 当我们执行一段java代码的时候，必须先加载这个类，类加载器是用来负责读取 Java 字节代码，并转换成java.lang.Class类的一个实例； 而在夹在当前类的时候要把父类给加载了，一层一层往上就通过引导类加载器创建一个初始类，启动了java虚拟机 虚拟机的执行 一个运行的java虚拟机有着一个清晰的任务：执行java程序 程序开始执行时他才运行，程
JVM整体结构
日拱一卒
04-22 229
JVM 之前阅读过《深入理解java虚拟机》这本书，也系统总结过关于JVM的一些基础知识，所以这篇文章不会再重复那些内容，只记录一些之前没关注到的内容或难以理解的内容。 虚拟机栈（线程栈） 虚拟机栈中有局部变量表、操作数栈、动态链接、方法出口等信息。 局部变量表用于存放线程中的基本数据类型和对象引用。操作数栈用于存储方法中的一些操作数，用完就会被回收。上图表示的是main方法运行时jvm虚拟机中关于main方法线程中栈帧的布局和操作数的运算过程。 对象的内存分配及GC ...
Java高并发编程实战，异步注解@Async自定义线程池
Java_zhujia的博客
11-16 1047
CPU密集型，线程池大小设置为N，也就是和cpu的线程数相同，可以尽可能地避免线程间上下文切换，但在实际开发中，一般会设置为N+1，为了防止意外情况出现线程阻塞，如果出现阻塞，多出来的线程会继续执行任务，保证CPU的利用效率。在需要异步执行的方法上加入@Async注解，并指定使用的线程池，当然可以不指定，直接写@Async。在使用@Async时，如果不指定线程池的名称，也就是不自定义线程池，@Async是有默认线程池的，使用的是Spring默认的线程池SimpleAsyncTaskExecutor。
谈谈SpringBoot中@Async注解使用的一些误区
09-19
在Spring Boot应用中，`@Async`注解是Spring框架提供的异步处理功能，它使得开发者可以方便地实现非阻塞式编程，提高应用程序的执行效率。然而，很多初学者在使用`@Async`时可能会遇到一些误区，导致程序运行结果不...
【多线程】@Async注解和线程池
weixin_45325628的博客
12-24 7337
快速了解@Async的使用
Java高并发编程实战5，异步注解@Async自定义线程池
学Java，找哪吒
09-27 1万+
Java高并发编程实战系列，打造精品专栏。
Java中@Async和直接新建一个线程有什么区别
09-11
Java中的@Async和直接新建一个线程都是用来实现异步编程的方式，但它们之间有一些区别。 @Async是Spring框架提供的一种异步编程方式，可以在方法上添加@Async注解，使得该方法在执行时会在一个新的线程中异步执行，而不是阻塞当前线程。在使用@Async时，Spring框架会自动创建一个线程池，并且可以设置线程池的大小等参数。 而直接新建一个线程则是通过Java中的Thread类来实现的，可以通过调用Thread的start()方法来启动一个新的线程。相比于@Async，直接新建一个线程需要自己手动管理线程的创建和销毁，同时也需要自己处理线程池大小等问题。 另外，@Async注解只能用在public方法上，而直接新建一个线程可以用在任何方法中。同时，@Async可以结合Spring中的其他特性，如事务、AOP等，提供更为灵活的异步编程方式。 总之，@Async和直接新建一个线程都可以用来实现异步编程，但它们的实现方式和使用场景有所不同，需要根据具体情况来选择使用哪种方式。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Alex·Guangzhou

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值