SpringBoot+Java8自定义线程池实现异步调用

SpringBoot(十三)异步任务 阅读详情

@Async()注解快速实现

@Async注解就能简单的将原来的同步函数变为异步函数;

  1. 在你需要异步的方法上使用@Async注解;@Async()注解可以写上线程池名称,这样就会指定使用的线程池,当然需要我们自定义线程池,这里我写上不同的线程池,最后可以看结果;
/**
 * fshows.com
 * Copyright (C) 2013-2019 All Rights Reserved.
 */
package com.example.thread.demo.service.impl;

import com.example.thread.demo.service.ThreadService;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;

import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

/**
 * @author liuyuan
 * @version ThreadServiceImpl.java, v 0.1 2019-11-01 11:06
 */
@Service
public class ThreadServiceImpl implements ThreadService {

    @Override
    // 线程池1
    @Async("taskExecutor1")
    public void doTaskA() throws InterruptedException {
        System.out.println("TaskA thread name->" + Thread.currentThread().getName());
        Long startTime = System.currentTimeMillis();
        TimeUnit.SECONDS.sleep(2);

        Long endTime = System.currentTimeMillis();
        System.out.println("TaskA 耗时:" + (endTime - startTime));
    }

    @Override
    // 线程池2
    @Async("taskExecutor2")
    public void doTaskB() throws InterruptedException {
        System.out.println("TaskB thread name->" + Thread.currentThread().getName());
        Long startTime = System.currentTimeMillis();
        TimeUnit.SECONDS.sleep(2);
        Long endTime = System.currentTimeMillis();
        System.out.println("TaskB耗时:" + (endTime - startTime));
    }
}
  1. 为了让@Async注解能够生效,还需要在Spring Boot的主程序中配置@EnableAsync注解;
package com.example.thread.demo;

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

/**
 * @author liuyuan
 */
@SpringBootApplication
@EnableAsync
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }

}

3.自定义线程池;当然可以不用定义线程池,会使用自带的线程池,但是通过线程池控制可以更好的控制并发;我这里用了三种线程池;

/**
 * fshows.com
 * Copyright (C) 2013-2019 All Rights Reserved.
 */
package com.example.thread.demo.config;

import com.google.common.util.concurrent.ThreadFactoryBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.concurrent.Executor;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 线程池配置
 *
 * @author liuyuan
 * @version ThreadPoolTaskConfig.java, v 0.1 2019-11-01 11:10
 */
@Configuration
@EnableAsync
public class ThreadPoolTaskConfig {

    /**
     * 核心线程数(默认线程数)
     */
    private static final int CORE_POOL_SIZE = 10;
    /**
     * 最大线程数
     */
    private static final int MAX_POOL_SIZE = 100;
    /**
     * 允许线程空闲时间(单位:默认为秒)
     */
    private static final int KEEP_ALIVE_TIME = 10;
    /**
     * 缓冲队列数
     */
    private static final int QUEUE_CAPACITY = 200;
    /**
     * 线程池名前缀
     */
    private static final String THREAD_NAME_PREFIX = "Async-Service-";

    /**
     * bean的名称,默认为首字母小写的方法名
     */
     // spring管理的线程池,顶级父类也是Executor
    @Bean("taskExecutor1")
    public ThreadPoolTaskExecutor taskExecutor1() {

        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(CORE_POOL_SIZE);
        executor.setMaxPoolSize(MAX_POOL_SIZE);
        executor.setQueueCapacity(QUEUE_CAPACITY);
        executor.setKeepAliveSeconds(KEEP_ALIVE_TIME);
        executor.setThreadNamePrefix(THREAD_NAME_PREFIX);

        // 线程池对拒绝任务的处理策略
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 初始化
        executor.initialize();
        return executor;
    }

    /*************************************************分割线*************************************************/

    private static final int THREADS = Runtime.getRuntime().availableProcessors() + 1;
    private final ThreadFactory threadFactory = new ThreadFactoryBuilder()
            // -%d不要少
            .setNameFormat("async-task-name-%d")
            .setDaemon(true)
            .build();

	// JDK原生线程池,建议返回值为ExecutorService,可以调用submit()方法启动线程
    @Bean("taskExecutor2")
    public Executor taskExecutor2() {
        return new ThreadPoolExecutor(THREADS, 2 * THREADS,
                5, TimeUnit.SECONDS,
                new LinkedBlockingQueue<>(1024),
                threadFactory, (r, executor) -> {
            // 打印日志,添加监控等
            System.out.println("task is rejected!");
        });
    }

    /*****************************************************分割线**************************************************/

	// NamedThreadFactory需要自己定义
    @Bean("taskExecutor3")
    public Executor taskExecutor3() {
        return new ThreadPoolExecutor(2, 50, 60L,
                TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(2048),
                new NamedThreadFactory("api-apply-thread"));
    }
}
  1. 运行结果,service层自行补齐;
/**
 * fshows.com
 * Copyright (C) 2013-2019 All Rights Reserved.
 */
package com.example.thread.demo.controller;

import com.example.thread.demo.service.ThreadService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 1. @author liuyuan
 2. @version ThreadDemo01.java, v 0.1 2019-11-01 11:02
 */
@RestController
@RequestMapping("/test")
public class ThreadDemo01 {

    @Autowired
    private ThreadService threadService;


    @GetMapping("/async")
    public String testAsync() throws Exception {
        System.out.println("主线程开始 name -->" + Thread.currentThread().getName());
        threadService.doTaskA();
        threadService.doTaskB();
        System.out.println("主线程结束 name -->" + Thread.currentThread().getName());
        return "Hello World";
    }
}

结果:主线程、TaskA和TaskB线程名都不相同,说明启用了不同的线程;
在这里插入图片描述

  1. 注意事项,以下情况会使@Async失效;
  • 异步方法使用static修饰 ;
  • 异步类没有使用@Component注解(或其他注解)导致spring无法扫描到异步类;
  • 类中需要使用@Autowired或@Resource等注解自动注入,不能自己手动new对象;
  • 如果使用SpringBoot框架必须在启动类中增加@EnableAsync注解 ;
  • 在Async方法上标注@Transactional是没用的。 在Async 方法调用的方法上标注@Transactional 有效;

Future、FutureTask介绍

Future是一个接口,该接口用来返回异步的结果,FutureTask是一个类,是Future 的一个实现。

  1. Future接口介绍;
public interface Future<V> {
 
 	// 取消任务的执行。参数指定是否立即中断任务执行,或者等等任务结束;返回值指是否取消成功;
    boolean cancel(boolean mayInterruptIfRunning);
 
 	// 任务是否已经取消,任务正常完成前将其取消,则返回 true;
    boolean isCancelled();
 
 	// 任务是否已经完成。需要注意的是如果任务正常终止、异常或取消,都将返回true;
    boolean isDone();
 
 	// 等待任务执行结束,然后获得V类型的结果,若无结果会阻塞至异步计算完成。
 	// InterruptedException 线程被中断异常, ExecutionException 任务执行异常,CancellationException 任务取消异常;
    V get() throws InterruptedException, ExecutionException;
 
 	// 同上面的get功能一样,多了设置超时时间。
 	// 参数timeout指定超时时间,uint指定时间的单位,在枚举类TimeUnit中有相关的定义。如果计 算超时,将抛出TimeoutException
    V get(long timeout, TimeUnit unit)
        throws InterruptedException, ExecutionException, TimeoutException;
}
  1. 使用方法;
    一般情况下,我们会结合Callable和Future一起使用,通过ExecutorService的submit方法执行Callable,并返回Future。
@Override
    public void doTaskE() {

        ThreadPoolTaskExecutor pool = threadPoolTaskConfig.taskExecutor1();

        // Lambda 是一个 callable, 提交后便立即执行,这里返回的是 FutureTask 实例
        Future<String> future = pool.submit(() -> {
            System.out.println("running task");
            Thread.sleep(1000);
            return "return task";
        });

        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
        }

        //前面的的 Callable 在其他线程中运行着,可以做一些其他的事情
        System.out.println("do something else");

        //等待 future 的执行结果,执行完毕之后打印出来
        try {
            System.out.println(future.get());
        } catch (InterruptedException e) {
        } catch (ExecutionException e) {

        }
    }
  1. 返回值;
    在这里插入图片描述

使用Future,返回异步的结果

还是和之前一样,我们使用@Async注解快速实现;

  1. 实现类代码,返回值自己定义,我这边定义一个map;
	@Override
    @Async("taskExecutor3")
    public Future<Map<String,String>> doTaskC() throws InterruptedException {

        System.out.println("TaskC thread name->" + Thread.currentThread().getName());
        Long startTime = System.currentTimeMillis();
        TimeUnit.SECONDS.sleep(2);
        Long endTime = System.currentTimeMillis();
        System.out.println("TaskC耗时:" + (endTime - startTime));

        Map<String, String> map = Maps.newHashMap();
        map.put("return","返回值是一个map!");
        return new AsyncResult<>(map);
    }
  1. 获取结果;
	@GetMapping("/async")
    public String testAsync() throws Exception {
        System.out.println("主线程开始 name -->" + Thread.currentThread().getName());

        //        threadService.doTaskA();
        //        threadService.doTaskB();
        
        Future<Map<String, String>> future = threadService.doTaskC();
        while (!future.isDone()) {
            System.out.println("Wait asyncTaskWithResult.");
            Thread.sleep(1000);
        }
        System.out.println("asyncTaskWithResult result is:" + future.get().toString());

        System.out.println("主线程结束 name -->" + Thread.currentThread().getName());
        return "Hello World";
    }
  1. 结果;
    在这里插入图片描述

使用FutureTask,返回异步的结果

采用普通的方式,开启线程;

  1. 实现类;
@Override
    public FutureTask<String> doTaskD() {

        Long startTime = System.currentTimeMillis();


        FutureTask<String> future = new FutureTask<>(() -> {

            TimeUnit.SECONDS.sleep(2);
            Long endTime = System.currentTimeMillis();
            System.out.println("TaskC耗时:" + (endTime - startTime));
            return "成功获取future异步任务结果,threadName = " + Thread.currentThread().getName();
        });

        Executor pool = threadPoolTaskConfig.taskExecutor3();

        pool.execute(future);

        return future;
    }
  1. 获取结果;
@GetMapping("/async")
    public String testAsync() throws Exception {
        System.out.println("主线程开始 name -->" + Thread.currentThread().getName());

        //        threadService.doTaskA();
        //        threadService.doTaskB();

        //        Future<Map<String, String>> future = threadService.doTaskC();
        
        FutureTask<String> future = threadService.doTaskD();
        boolean flag = true;
        while (flag) {
            //异步任务完成并且未被取消,则获取返回的结果
            if (future.isDone() && !future.isCancelled()) {
                System.out.println("asyncTaskWithResult result is:" + future.get());
                flag = false;
            }
        }

        System.out.println("主线程结束 name -->" + Thread.currentThread().getName());
        return "Hello World";
    }
  1. 结果;
    在这里插入图片描述

CompletableFuture和CompletionStage介绍

  1. Future模式的缺点;
  • Future虽然可以实现获取异步执行结果的需求,但是它没有提供通知机制,我们无法得知Future什么时候完成;
  • Future是Java 5添加的类,用来描述一个异步计算的结果,但是获取一个结果时方法较少,要么通过轮询isDone,确认完成后,调用get()获取值,要么调用get()设置一个超时时间。但是这个get()方法会阻塞住调用线程,这种阻塞的方式显然和我们的异步编程的初衷相违背。
  1. CompletableFuture介绍;
  • CompletableFuture能够将回调放到与任务不同的线程中执行,也能将回调作为继续执行的同步函数,在与任务相同的线程中执行。它避免了传统回调最大的问题,那就是能够将控制流分离到不同的事件处理器中。

  • CompletableFuture弥补了Future模式的缺点。在异步的任务完成后,需要用其结果继续操作时,无需等待。可以直接通过thenAccept、thenApply、thenCompose等方式将前面异步处理的结果交给另外一个异步事件处理线程来处理。

  1. CompletableFuture的方法介绍;
  • CompletableFuture的静态工厂方法
    在这里插入图片描述
    runAsync 和 supplyAsync 方法的区别是runAsync没有返回值;
  1. CompletionStage介绍;
    CompletionStage是一个接口,从命名上看得知是一个完成的阶段,它里面的方法也标明是在某个运行阶段得到了结果之后要做的事情。
  • 进行变换
public <U> CompletionStage<U> thenApply(Function<? super T,? extends U> fn);
public <U> CompletionStage<U> thenApplyAsync(Function<? super T,? extends U> fn);
public <U> CompletionStage<U> thenApplyAsync(Function<? super T,? extends U> fn,Executor executor);

首先说明一下已Async结尾的方法都是可以异步执行的,如果指定了线程池,会在指定的线程池中执行,如果没有指定,默认会在ForkJoinPool.commonPool()中执行,下文中将会有好多类似的,都不详细解释了。关键的入参只有一个Function,它是函数式接口,所以使用Lambda表示起来会更加优雅。它的入参是上一个阶段计算后的结果,返回值是经过转化后结果。

例如:

@Override
    public void doTaskG() {

        String result = CompletableFuture.supplyAsync(() -> {

            System.out.println("线程1" + Thread.currentThread().getName());
            return "hello";
        }, threadPoolTaskConfig.taskExecutor1()).thenApplyAsync(s -> {

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程2" + Thread.currentThread().getName());
            return s + "dosomething";
        }, threadPoolTaskConfig.taskExecutor2()).join();
        System.out.println("return: " + result);
    }
public String testAsync() throws Exception {
        System.out.println("主线程开始 name -->" + Thread.currentThread().getName());

                threadService.doTaskG();

        System.out.println("主线程结束 name -->" + Thread.currentThread().getName());
        return "Hello World";
    }

结果:
![在这里插入图片描述](https://img-blog.csdnimg.cn/20191105170749605.png
分析:可以看到,我使用的是异步方法,并且结果也开启了了两个线程,但是获取返回值还是阻塞了主线程的执行;

  • 进行消耗
public CompletionStage<Void> thenAccept(Consumer<? super T> action);
public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action);
public CompletionStage<Void> thenAcceptAsync(Consumer<? super T> action,Executor executor);

thenAccept是针对结果进行消耗,因为他的入参是Consumer,有入参无返回值。

例如:

@Override
    public void doTaskH() {

        CompletableFuture.supplyAsync(() -> {

            System.out.println("线程1" + Thread.currentThread().getName());
            return "CompletableFuture";
        }, threadPoolTaskConfig.taskExecutor1()).thenAcceptAsync(s -> {

            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程2" + Thread.currentThread().getName());
            System.out.println("return: " + s + "===" + "thenAcceptAsync");
        }, threadPoolTaskConfig.taskExecutor2());
    }
public String testAsync() throws Exception {
        System.out.println("主线程开始 name -->" + Thread.currentThread().getName());

                threadService.doTaskH();

        System.out.println("主线程结束 name -->" + Thread.currentThread().getName());
        return "Hello World";
    }

结果:
在这里插入图片描述
分析:执行supplyAsync()和thenAcceptAsync()时分别开了不同的线程池,并且返回值没有阻塞主线程,也就是说实现了异步处理的结果并且将结果交给另外一个异步事件处理线程来处理。

注意:在函数结尾千万不要加.join()方法,否则还是会阻塞处理返回值;

参考文档

SpringBoot实践(九):Java8流处理stream与completableFuture异步编程 流处理stream结合函数式编程规范,极大提升编程效率,减少代码量,而异步编程completableFuture的使用,则能够更加清晰地表述出业务逻辑,方法的异步调用关系路径很好滴描述了业务脉络; Stream 这里先构造2个对象,student和teacher,teacher拥有多个student对象,经常有类似使用teacher对象后对student操作的场景,使用流处理比for、foreach、Iterator更优雅;...... 阅读详情

相关推荐

Java线程池监控及CompletableFuture详解

Java线程池监控及最佳实践。Springboot整合线程池。线程池为多线程创建的开销问题以及线程管理提供了解决方案。通过多任务下线程的重用,即线程池中的线程执行完一个任务后并不立即销毁,而是可以继续执行其它任务。将线程创建的开销摊薄到了多任务上,便能获得高并发环境下系统性能上的提升。

鸟哥哥的专栏 2457

SpringBoot2.0之异步任务(async)和 java8 CompletableFuture的调用

1.我们先介绍java8 的异步调用:CompletableFuture 用CompletableFuture.supplyAsync()定义要执行的异步任务 public class java8Async { public static void main(String[] args) { ExecutorService executor = Executors.newFixedTh...

lx1309244704的博客 6033

ubuntu打实时内核补丁教程以及安装后显卡驱动问题解决方法

在ubuntu20.04上安装成功,亲测有效 目录ubuntu打实时内核补丁教程1、下载实时内核2、解压和打补丁(patch)3、安装依赖和编译安装4、修改一些文件,便于之后切换内核5、重启电脑实时内核版本下安装nvidia显卡驱动的问题1、先切换回之前的内核(非实时)版本2、重装之前内核(非实时)版本下的显卡驱动3、切换回实时内核(按照上面的步骤)4、在实时内核下安装显卡驱动 ubuntu打实时内核补丁教程 安装目标系统:ubuntu20.04 电脑配置:i9,2080ti 1、下载实时内核 打开终端,输

weixin_39275295的博客 7996

java8 异步调用_Java8学习之异步编程

异步编程所谓异步其实就是实现一个无需等待被调用函数的返回值而让操作继续运行的方法创建任务并执行任务无参创建CompletableFuture noArgsFuture = new CompletableFuture<>();传入相应任务,无返回值runAsync方法可以在后台执行异步计算,但是此时并没有返回值。持有一个Runnable对象。CompletableFuture noRet...

weixin_36289211的博客 801

三极管共集电极放大电路详解:射极跟随器的原理、计算与应用

三极管放大电路是模拟电子技术的基石,常见组态包括共发射极、共基极和共集电极。其中共集电极电路因输入电阻大、输出电阻小、电压增益接近1的特性,常被用作射极跟随器,在信号缓冲、级间隔离和低阻抗负载驱动等场景中发挥关键作用。其核心价值并非电压放大,而是完成阻抗变换,将高内阻信号源转换为低内阻输出,同时保持信号幅值基本不变。理解其静态工作点计算与动态参数推导(如电压增益、输入输出电阻)是设计实用电路的前提。本文结合12V电源下的具体设计实例和仿真验证,梳理了从电路识别、参数计算到工程实践的完整流程,并指出常见设计误

weixin_29193259的博客 387

智警杯1.4---excel可视化

知识点

lulu001128的博客 953

Java 的 8 种异步实现方式,让性能飞起来

异步执行对于开发者来说并不陌生,在实际的开发过程中,很多场景多会使用到异步,相比同步执行,异步可以大大缩短请求链路耗时时间,比如:发送短信、邮件、异步更新等,这些都是典型的可以通过异步实现的场景。异步的八种实现方式线程ThreadFuture异步框架CompletableFutureSpring注解@AsyncSpring ApplicationEvent事件消息队列第三方异步框架,比如Hutoo...

天行健,君子以自强不息;地势坤,君子以厚德载物。 7238

Unity3D实战:5分钟搞定RTSP监控视频流播放(附完整代码)

本文详细介绍了如何在Unity3D中快速实现低延迟RTSP监控视频流播放,提供完整代码和优化方案。通过Video Player组件和FFmpeg集成,开发者可以轻松应对智能家居和安防监控领域的实时视频流挑战,显著降低延迟并提升性能。

weixin_29015051的博客 594

SpringBoot利用@Async注解实现异步调用

前言:异步编程是让程序并发运行的一种手段。它允许多个事情同时发生,当程序调用需要长时间运行的方法时,它不会阻塞当前的执行流程,程序可以继续运行,当方法执行完成时通知给主线程根据需要获取其执行结果或者失败异常的原因。使用异步编程可以大大提高我们程序的吞吐量,可以更好的面对更高的并发场景并更好的利用现有的系统资源,同时也会一定程度上减少用户的等待时间等。 一、异步编程 1.1、什么是异步调用? 异步调用是相对于同步调用而言的,同步调用是指程序按预定顺序一步步执行,每一步必须等到上一步执行完后才能执行,异步

何哥的博客 1万+

OPENSSL使用方法

预备知识KEY 通常指私钥。CSR 是 Certificate Signing Request 的缩写,即证书签名请求,这不是证书,只是包含申请证书的基本信息。生成证书时要把这个提交给权威的证书颁发机构,颁发机构审核通过之后,再根据这些申请信息生成相应的证书。CRT 即 certificate的缩写,即证书。 X.509 是一种证书格式。对X.509证书来说,认证者总是CA或由CA指定的人,一份...

zxm8513优快云博客 1217

本地Pycharm连接远程服务器详细配置过程(直接在本地使用服务器显卡,很棒)

相信很多人都遇见过这种情况:实验室成员使用同一台服务器,每个人拥有自己的独立账号,我们可以使用服务器更好的配置完成实验,毕竟自己哪有money拥有自己的3090呢。

NorthSmile的博客 4万+

Springboot实现方法异步调用

文章目录SpringBoot中使用 async实现异步调用定义线程池使用实战单元测试注意事项Spring中用ThreadPoolTaskExecutor实现异步调用 SpringBoot中使用 async实现异步调用 基于注解的使用方式包括如下三步: 启动类加上@EnableAsync(也可以在配置类中加上) 配置类中完成异步线程池的导入(这一个可以不要,采用默认的) 需要异步调用的方法加上@A...

Apple_Boy的博客 5389

【即插即用模块】卷积篇 | TCSVT 2025 | MFACB:多尺度膨胀融合,快速扩大感受野,多尺度特征精准捕捉!

本文提出了一种新型多尺度融合膨胀卷积模块MFACB,用于增强语义分割任务中的特征表达能力。该模块通过三分支串联膨胀卷积结构快速扩大感受野,采用双路径融合机制(基础信息路径+多尺度信息路径)实现高效上下文聚合。相比传统卷积块,MFACB在保持轻量化的同时显著提升了多尺度特征捕捉能力,实验表明其性能优于基础残差块。该模块支持自定义膨胀率和步长调整,可灵活嵌入不同网络阶段,适用于需要特征增强的视觉任务。

主要更新底层视觉(去噪、超分等)相关的科研内容,形式为【论文精读】+【论文复现】 312

SpringBoot使用线程池

SpringBoot使用线程池 软件环境 名称 版本号 jdk 1.8 springboot 2.1.6 maven 3.3.9 1.Java中创建线程池 只会介绍java中线程池的核心类ThreadPoolExecutor,其他用法请自行查询 1.1 ThreadPoolExecutor类介绍 jdk1.8 源码 删减部分内容 package java...

Cain的博客 2万+

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

SpringBoot中的异步调用@Async

如何开启异步调用 在SpringBoot中,只需要给方法加上@Async注解,就能将同步方法变为异步调用。 首先在启动类上添加@EnableAsync,即开启异步调用。 /** * @author qcy */ @SpringBootApplication @EnableAsync public class AsyncApplication { public static void main(String[] args) { SpringApplication.run(

阳阳的博客 1365

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

SpringBoot中使用@Async实现异步调用

SpringBoot中使用@Async实现异步调用

YIYIYI 1530

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术,以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索,主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式,计算机控制系统的数学描述与基本分析方法,以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

Java异步调用的几种方式

一、通过创建新线程 二、通过线程池 三、通过@Async注解 四、通过CompletableFuture 日常开发中,会经常遇到说,前台调服务,然后触发一个比较耗时的异步服务,且不用等异步任务的处理结果就对原服务进行返回。这里就涉及的Java异步调用的一个知识。下面本文尝试将Java异步调用的多种方式进行归纳。 一、通过创建新线程 首先的我们得认识到,异步调用的本质,其实是通过开启一个新的线程来执行。如以下例子: 1 2 3 4 5 6

weixin_46217160的博客 5635

SpringBoot实现方法异步调用的正确方式

一、前言在我们平时的开发过程中,会遇到一个流程中各个逻辑并非紧密相连的业务,比如查询文章详情后更新文章阅读量,其实对于用户来说,最关心的是能快速获取文章,至于更新文章阅读量,用户可能并不关心。因此,对于这类逻辑并非紧密相连的业务,可以将逻辑进行拆分,让用户无需等待更新文章阅读量,查询时直接返回文章信息,缩短同步请求的耗时,...

weixin_34052714的博客 526

SpringBoot + @Async实现优雅的异步调用

点击上方“Java基基”,选择“设为星标”做积极的人,而不是积极废人!每天14:00更新文章,每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路,很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT 源码解析...

weixin_44421461的博客 1643

SpringBoot系列——@Async优雅的异步调用

前言   众所周知,java的代码是同步顺序执行,当我们需要执行异步操作时我们需要创建一个新线程去执行,以往我们是这样操作的: /** * 任务类 */ class Task implements Runnable { @Override public void run() { System.out.println(Thread.currentThread().getName() + ":异步任务");

u012045045的博客 1402

springboot实现异步调用@Async

介绍 所谓的异步执行其实就是使用多线程的方式实现异步调用 异步有什么好处呢? 如果一个业务逻辑执行完成需要多个步骤,也就是调用多个方法去执行, 这个时候异步执行比同步执行相应更快。不过要注意异步请求的顺序和处理结果的顺序最好一致,不然就达不到效果了 注意事项 1、在默认情况下,未设置TaskExecutor时,默认是使用SimpleAsyncTaskExecutor这个线程池,但此线...

lucky_love816的博客 695

玄星幻月002-@Async-自定义线程池

线程池 异步调用 @Async

zhi_zixing的博客 3015

SpringBoot之异步调用

什么是异步调用? 异步调用是相对于同步调用而言的,同步调用是指程序按预定顺序一步步执行,每一步必须等到上一步执行完后才能执行,异步调用则无需等待上一步程序执行完即可执行。 如何实现异步调用? 多线程,这是很多人第一眼想到的关键词,没错,多线程就是一种实现异步调用的方式。 在非spring目项目中我们要实现异步调用的就是使用多线程方式,可以自己实现Runable接口或者集成Thread类,或者使用j...

heima201907的博客 175

杂记之@Asyns异步调用的正确打开姿势

环境: spring;spring boot 摘要说明: 项目开发过程中往往会出现需异步调用的情况,以便提高系统的响应速度或者提高部分业务的处理时间; 但异步调用需要根据系统的承受能力做好相关配置,而不是放任随意使用; 如系统批跑5000条数据做相关业务处理;若循环异步处理,则很可能将数据库给压垮; 所以这里需要控制系统异步线程池的大小及线程池的满额执行策略; 步骤: 1.@Asy...

叶落自飘零的博客 2187

SpringBoot 使用 CompletableFuture 实现非阻塞异步编程

在前面的博客:https://blog.youkuaiyun.com/BiandanLoveyou/article/details/83586356 我们讲解了如何使用线程池Executor + Future +@Async 实现异步调用。今天讲解一个 JDK1.8 的异步类:CompletableFuture。 什么是非阻塞异步编程? 所谓非阻塞异步编程方法,简单地说,就是不用等待返回结果的多线程的回调方法的封装。相比于阻塞式异步回调方法,非阻塞异步编程方法使用一个监听器,这样在使用回调的过...

流放深圳 1万+
上一篇: Java线程池的正确创建方式
下一篇: SpringBoot多数据源配置
String NUll
博客等级 码龄8年 210粉丝 61原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值