SpringBoot入门建站全系列（二十二）异步任务执行的几种方式

最新推荐文章于 2023-06-07 22:18:53 发布
最新推荐文章于 2023-06-07 22:18:53 发布
阅读量377 收藏 1
点赞数
分类专栏： SpringBoot专题 文章标签： Springboot 异步 异步任务执行 多线程 多进程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feiyangtianyao/article/details/99621335
版权

SpringBoot入门建站全系列（二十二）异步任务执行的几种方式

一、概述

异步调用是相对于同步调用而言的，同步调用是指程序按预定顺序一步步执行，每一步必须等到上一步执行完后才能执行，异步调用则无需等待上一步程序执行完即可执行。

实现异步任务的方式有很多，但是可以总结为多线程异步和多进程异步。

多线程异步：

  • 多线程实现异步就是新建个线程，将任务交给新线程执行。

  • 不管是自己new Thread实现异步，还是使用ThreadPoolTaskExecutor线程池，还是使用Spring的@EnableAsync注解，这些都是多线程实现的异步。

多进程异步：

  • 将任务交给另外一个进程处理，已经不在本应用中了。

  • 比如将任务交给MQ，这个就是异步操作了。因为交给MQ以后，你不必等待结果返回。

  • 当然，如果你调用另外一个应用/进程，另外的一个应用/进程将任务加入任务队列，然后立即返回你成功失败，那这个过程也属于异步任务。这个过程就是MQ做的事情了。。

本篇重点讲述多线程异步任务的执行方式。多进程方式可以查看《SpringBoot入门建站全系列（十七）整合ActiveMq（JMS类消息队列）》和《SpringBoot入门建站全系列（十八）整合RabbitMQ（AMQP类消息队列）》中的消息发送方式。

首发地址：

  品茗IT-同步发布

品茗IT提供在线支持：

  一键快速构建Spring项目工具

  一键快速构建SpringBoot项目工具

  一键快速构建SpringCloud项目工具

  一站式Springboot项目生成

  Mysql一键生成Mybatis注解Mapper

  Mysql一键生成SpringDataRest项目

如果大家正在寻找一个java的学习环境，或者在开发中遇到困难，可以加入我们的java学习圈，点击即可加入，共同学习，节约学习时间，减少很多在学习中遇到的难题。

二、前言

多线程的异步任务执行有几种方式，还是前面所说的那样，方式虽然不同，但原理是一样的，就是在新线程中执行任务，但是还是要说一下这几种方式。

  • new Thread 普通线程方式执行；

  • ThreadPool线程池，线程使用频繁的时候，减少线程创建回收的开销。实现方式有多种，但是jdk1.5开始支持线程池，就在java.util.concurrent里。

  • Spring提供的@Async注解。其实也是基于线程池。

  • 注意Runnable和Callable在异步任务中的应用，一个不带返回值，一个带返回值而已。

本文是在Springboot环境中测试的。引入spring-boot-starter-web即可。如果不会搭建，可以打开这篇文章看一看《SpringBoot入门建站全系列（一）项目建立》。

在web项目中测试会比较方便，我们利用RequestContextHolder获取ThreadLocal的Request对象来判断线程是否改变了

假设我们要执行的任务是这样的, 为了异步执行AsyncTaskService 中的asyncTask方法：

package com.cff.springbootwork.async.service;

import javax.servlet.http.HttpServletRequest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Service;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

@Service
public class AsyncTaskService {
	private Logger log = LoggerFactory.getLogger(this.getClass());

	/**
	 * 普通的一方法而已，供异步任务调用
	 */
	public void asyncTask() {
		RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();
		if (requestAttributes != null) {
			HttpServletRequest curRequest = ((ServletRequestAttributes) requestAttributes).getRequest();
			log.info("异步任务开始执行，当前请求属性test为：{}", curRequest.getAttribute("test"));
		} else {
			log.info("异步任务不是同一个线程了，别想拿ThreadLocal对象了");
		}

		try {
			Thread.sleep(5000);
			log.info("我是异步任务，我就是个打印！");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		log.info("5s后异步任务终于执行完成");
	}

}

三、普通线程方式

首先我们在Request中塞入一个值，后面用来获取判断是否是主线程。

然后用new Thread新建线程执行异步任务。

我们将逻辑写在AsyncService中，来调用AsyncTaskService的asyncTask方法。

AsyncService:

/**
	 * 测试new Thread 异步任务
	 */
	public void asyncThread() {
		log.info("开始执行任务");
		HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
				.getRequest();

		log.info("请求属性test为：{}", request.getAttribute("test"));

		Thread thread1 = new Thread(new Runnable() {
			public void run() {
				asyncTaskService.asyncTask();
			}
		});
		thread1.start();

		HttpServletRequest afterRequest = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
				.getRequest();
		log.info("任务提前执行完成，开始返回,请求属性test为：{}", afterRequest.getAttribute("test"));
	}

结果如下：

2019-08-08 16:39:50,516 [http-nio-8080-exec-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 开始执行任务
2019-08-08 16:39:50,517 [http-nio-8080-exec-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 请求属性test为：asdasd
2019-08-08 16:39:50,522 [http-nio-8080-exec-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 任务提前执行完成，开始返回,请求属性test为：asdasd
2019-08-08 16:39:50,530 [Thread-4][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncTaskService] 异步任务不是同一个线程了，别想拿ThreadLocal对象了
2019-08-08 16:39:55,530 [Thread-4][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncTaskService] 我是异步任务，我就是个打印！
2019-08-08 16:39:55,530 [Thread-4][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncTaskService] 5s后异步任务终于执行完成

  • 首先获取下request的test属性，能获取到；

  • 执行异步任务，拿不到request对象了，因为不是同一个线程，ThreadLocal没有。

  • 程序直接返回了，异步任务5s以后才执行完。

四、线程池方式

首先我们在Request中塞入一个值，后面用来获取判断是否是主线程。

然后将异步任务扔给线程池执行。

这里我们分别使用Runnable和Callable来测试下。

先建立一个线程池：

package com.cff.springbootwork.async.service;

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

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

import org.springframework.stereotype.Service;

@Service
public class ThreadPoolService {
	private ExecutorService executor;

	@PostConstruct
	public void init() {
//		executor = new ThreadPoolExecutor(20, 30, 60L, TimeUnit.SECONDS, new LinkedBlockingDeque<>(),
//				new ThreadPoolExecutor.AbortPolicy());
		
		executor = Executors.newCachedThreadPool();
	}

	public void execute(Runnable task) {
		executor.execute(task);
	}

	public <T> Future<T> submit(Callable<T> task) {
		return executor.submit(task);
	}

	@PreDestroy
	public void shutdown() {
		executor.shutdown();
	}
}
4.1 Runnable普通异步任务

我们将逻辑写在AsyncService中，来调用AsyncTaskService的asyncTask方法。

AsyncService:

/**
	 * 测试 线程池 异步任务
	 */
	public void asyncThreadPool() {
		log.info("开始执行任务");
		HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
				.getRequest();

		log.info("请求属性test为：{}", request.getAttribute("test"));

		threadPoolService.execute(new Runnable() {
			public void run() {
				asyncTaskService.asyncTask();
			}
		});

		HttpServletRequest afterRequest = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
				.getRequest();
		log.info("任务提前执行完成，开始返回,请求属性test为：{}", afterRequest.getAttribute("test"));
	}

结果如下：

2019-08-08 16:44:19,136 [http-nio-8080-exec-4][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 开始执行任务
2019-08-08 16:44:19,136 [http-nio-8080-exec-4][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 请求属性test为：asdasd
2019-08-08 16:44:19,137 [http-nio-8080-exec-4][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 任务提前执行完成，开始返回,请求属性test为：asdasd
2019-08-08 16:44:19,138 [pool-1-thread-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncTaskService] 异步任务不是同一个线程了，别想拿ThreadLocal对象了
2019-08-08 16:44:24,140 [pool-1-thread-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncTaskService] 我是异步任务，我就是个打印！
2019-08-08 16:44:24,140 [pool-1-thread-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncTaskService] 5s后异步任务终于执行完成

  • 首先获取下request的test属性，能获取到；

  • 执行异步任务，拿不到request对象了，因为不是同一个线程，ThreadLocal没有。

  • 程序直接返回了，异步任务5s以后才执行完。

和new Thread方式一样。唯一区别就是它是线程池，线程可以回收，线程使用频繁的时候，减少线程创建回收的开销。

4.2 Callable异步任务返回结果

我们将逻辑写在AsyncService中，来调用AsyncTaskService的asyncTask方法。

AsyncService:

/**
	 * 测试 线程池 异步任务 Future回调
	 */
	public void asyncFuturePool() {
		log.info("开始执行任务");
		HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
				.getRequest();

		log.info("请求属性test为：{}", request.getAttribute("test"));

		Callable<String> callable = new Callable<String>() {
			@Override
			public String call() throws Exception {
				asyncTaskService.asyncTask();
				return "1111";
			}
		};

		Future<String> future = threadPoolService.submit(callable);

		try {
			// future.get(); // 阻塞函数，如果直接用，它就一直阻塞，就不是异步了。
			if (future.isDone()) {
				log.info("这么快就完成了？不可能！");
				String result = future.get();
				log.info("任务结果为：{}", result);
			}
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		} catch (ExecutionException e1) {
			e1.printStackTrace();
		}

		HttpServletRequest afterRequest = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
				.getRequest();
		log.info("任务提前执行完成，开始返回,请求属性test为：{}", afterRequest.getAttribute("test"));
	}

如果注掉future.get()，结果如下：

2019-08-08 16:46:44,001 [http-nio-8080-exec-7][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 开始执行任务
2019-08-08 16:46:44,002 [http-nio-8080-exec-7][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 请求属性test为：asdasd
2019-08-08 16:46:44,003 [http-nio-8080-exec-7][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 任务提前执行完成，开始返回,请求属性test为：asdasd
2019-08-08 16:46:44,003 [pool-1-thread-2][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncTaskService] 异步任务不是同一个线程了，别想拿ThreadLocal对象了
2019-08-08 16:46:49,003 [pool-1-thread-2][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncTaskService] 我是异步任务，我就是个打印！
2019-08-08 16:46:49,003 [pool-1-thread-2][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncTaskService] 5s后异步任务终于执行完成

这个过程和4.1完全一样了。

如果不注掉future.get()，结果如下：

2019-08-08 16:48:02,472 [http-nio-8080-exec-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 开始执行任务
2019-08-08 16:48:02,472 [http-nio-8080-exec-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 请求属性test为：asdasd
2019-08-08 16:48:02,478 [pool-1-thread-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncTaskService] 异步任务不是同一个线程了，别想拿ThreadLocal对象了
2019-08-08 16:48:07,478 [pool-1-thread-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncTaskService] 我是异步任务，我就是个打印！
2019-08-08 16:48:07,478 [pool-1-thread-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncTaskService] 5s后异步任务终于执行完成
2019-08-08 16:48:07,478 [http-nio-8080-exec-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 这么快就完成了？不可能！
2019-08-08 16:48:07,478 [http-nio-8080-exec-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 任务结果为：1111
2019-08-08 16:48:07,478 [http-nio-8080-exec-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 任务提前执行完成，开始返回,请求属性test为：asdasd

虽然拿到了结果，也使用了多线程，但是这个过程变成同步了，因为主线程一直等待另外一个线程执行完才执行下一步。

五、Spring的@Async注解方式

@Async注解的方法，不能和调用方法在同一个类中，因为它是动态代理调用的。同一个类中动态代理个毛啊。。

首先要使用注解@EnableAsync开启异步执行功能。

package com.cff.springbootwork.async.config;

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@EnableAsync
public class AsyncConfig {
	
}
5.1 同一个类中测试

我们将逻辑写在AsyncService中，新建个方法asyncTaskAnnotation，加上@Async注解并调用AsyncTaskService的asyncTask方法，进行测试。

AsyncService:

/**
	 * 测试 @Async 对异步任务的支持
	 */
	@Async
	public void asyncTaskAnnotation() {
		asyncTaskService.asyncTask();
	}

	/**
	 * 测试 Spring的@Async 对异步任务的支持， 同一个类内的方法不能实现异步
	 */
	public void asyncSpringAnnotationOne() {
		log.info("开始执行任务");
		HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
				.getRequest();

		log.info("请求属性test为：{}", request.getAttribute("test"));

		asyncTaskAnnotation();

		HttpServletRequest afterRequest = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
				.getRequest();
		log.info("任务提前执行完成，开始返回,请求属性test为：{}", afterRequest.getAttribute("test"));
	}

测试结果如下：

2019-08-08 16:54:09,957 [http-nio-8080-exec-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 开始执行任务
2019-08-08 16:54:09,957 [http-nio-8080-exec-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 请求属性test为：asdasd
2019-08-08 16:54:09,962 [http-nio-8080-exec-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncTaskService] 异步任务开始执行，当前请求属性test为：asdasd
2019-08-08 16:54:14,962 [http-nio-8080-exec-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncTaskService] 我是异步任务，我就是个打印！
2019-08-08 16:54:14,962 [http-nio-8080-exec-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncTaskService] 5s后异步任务终于执行完成
2019-08-08 16:54:14,962 [http-nio-8080-exec-1][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 任务提前执行完成，开始返回,请求属性test为：asdasd

可以看出，异步任务竟然可以拿到request的test属性了，表明这压根就是同一个线程，@Async无效。

5.2 不同类中测试

我们将逻辑写在AsyncService中，在AsyncTaskService新建个方法asyncTaskAnnotation，加上@Async注解并调用asyncTask方法，进行测试。

AsyncService:

/**
	 * 测试 Spring的@Async 对异步任务的支持， 不同类的方法可以实现异步
	 */
	public void asyncSpringAnnotationMuti() {
		log.info("开始执行任务");
		HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
				.getRequest();

		log.info("请求属性test为：{}", request.getAttribute("test"));

		asyncTaskService.asyncTaskAnnotation();

		HttpServletRequest afterRequest = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes())
				.getRequest();
		log.info("任务提前执行完成，开始返回,请求属性test为：{}", afterRequest.getAttribute("test"));
	}

测试结果如下：

2019-08-08 16:56:50,964 [http-nio-8080-exec-6][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 开始执行任务
2019-08-08 16:56:50,964 [http-nio-8080-exec-6][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 请求属性test为：asdasd
2019-08-08 16:56:50,964 [http-nio-8080-exec-6][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncService] 任务提前执行完成，开始返回,请求属性test为：asdasd
2019-08-08 16:56:50,965 [SimpleAsyncTaskExecutor-2][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncTaskService] 异步任务不是同一个线程了，别想拿ThreadLocal对象了
2019-08-08 16:56:55,965 [SimpleAsyncTaskExecutor-2][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncTaskService] 我是异步任务，我就是个打印！
2019-08-08 16:56:55,965 [SimpleAsyncTaskExecutor-2][IP:|USER:][INFO  com.cff.springbootwork.async.service.AsyncTaskService] 5s后异步任务终于执行完成

可以看出，异步任务拿不到request对象了，@Async正常使用。

六、 测试类及Service完整代码

AsyncRest：

package com.cff.springbootwork.async.web;

import javax.servlet.http.HttpServletRequest;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.cff.springbootwork.async.service.AsyncService;

/**
 * 测试乐异步任务
 * 
 * @author fufei
 *
 */
@RestController
@RequestMapping("/async")
public class AsyncRest {

	@Autowired
	AsyncService asyncService;

	@RequestMapping(value = "/thread", method = { RequestMethod.GET })
	public String thread(HttpServletRequest request) {
		request.setAttribute("test", "asdasd");
		asyncService.asyncThread();
		return "0000";
	}

	@RequestMapping(value = "/pool", method = { RequestMethod.GET })
	public String pool(HttpServletRequest request) {
		request.setAttribute("test", "asdasd");
		asyncService.asyncThreadPool();
		return "0000";
	}

	@RequestMapping(value = "/future", method = { RequestMethod.GET })
	public String future(HttpServletRequest request) {
		request.setAttribute("test", "asdasd");
		asyncService.asyncFuturePool();
		return "0000";
	}

	@RequestMapping(value = "/springOne", method = { RequestMethod.GET })
	public String springOne(HttpServletRequest request) {
		request.setAttribute("test", "asdasd");
		asyncService.asyncSpringAnnotationOne();
		return "0000";
	}

	@RequestMapping(value = "/springMuti", method = { RequestMethod.GET })
	public String springMuti(HttpServletRequest request) {
		request.setAttribute("test", "asdasd");
		asyncService.asyncSpringAnnotationMuti();
		return "0000";
	}
}

AsyncService：

AsyncTaskService:

详细完整的代码，可以访问品茗IT-博客《SpringBoot入门建站全系列（二十二）异步任务执行的几种方式》进行查看

品茗IT-博客专题:https://www.pomit.cn/lecture.html汇总了Spring专题、Springboot专题、SpringCloud专题、web基础配置专题。

快速构建项目

Spring组件化构建

SpringBoot组件化构建

SpringCloud服务化构建

喜欢这篇文章么，喜欢就加入我们一起讨论SpringBoot使用吧！
品茗IT交流群

逍遥天扬
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot异步任务使用方法详解
08-19
主要介绍了SpringBoot异步任务使用方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
SpringBoot的四种异步处理，写这篇文章，我自己先学到了
程序新视界
02-21 9435
最近更新了一系列关于异步和回调的文章，比如《一篇文章，搞明白异步和多线程的区别》、《两个经典例子让你彻底理解java回调机制》、《异步请求和异步调用有区别？》，大家感兴趣的话可温习一下。 今天再带大家学习汇总一下SpringBoot中异步处理的4种形式，下面开始正文： 前言 在网络上有关于SpringBoot的异步请求和异步调有两种说法，经过调用这两种说法本质上就是一回事，在《异步请求和异步调用有区别？》一种，已经做过解释了。 同时，我们也知道了“服务实现的异步与同步特性完全独立于客户端调用的异步和同步特性
SpringBoot（十三）异步任务
m0_65992672的博客
04-28 3033
SpringBoot（十三）异步任务
总结下Spring boot异步执行逻辑的几种方式
weixin_43241706的博客
04-18 1346
Future及FutureTask就不说了，直接说完美形态：CompletableFuture，JDK8中新增加了一个包含50个方法左右的类CompletableFuture，提供了非常强大的Future的扩展功能，可以帮助我们简化异步编程的复杂性，提供了函数式编程的能力，可以通过回调的方式处理计算结果，并且提供了转换和组合CompletableFuture的方法。优势是：（不用记知道即可）可以在代码里面显式的创建线程，比如第一种方式，但是如果线程多的话会消耗系统资源，效率。低下并且还会降低系统稳定性。
SpringBoot实现异步调用的几种方式
qinxun2008081的博客
06-07 6494
SpringBoot实现异步调用的几种方式
SpringBoot 8种异步实现方式
justlpf的专栏
05-15 3483
异步执行对于开发者来说并不陌生，在实际的开发过程中，很多场景多会使用到异步，相比同步执行，异步可以大大缩短请求链路耗时时间，比如：「发送短信、邮件、异步更新等」，这些都是典型的可以通过异步实现的场景。
SpringBoot异步调用 实现方式
崔向阳@李晓的博客
03-30 584
534545
SpringBoot 如何异步编程，老鸟们都这么玩的
飘渺Jam的博客
12-01 2815
大家好，我是飘渺。今天继续给大家带来SpringBoot老鸟系列的第六篇，来聊聊在SpringBoot项目中如何实现异步编程。 老鸟系列文章导读： 1. SpringBoot 如何统一后端返回格式？老鸟们都是这样玩的！ 2. SpringBoot 如何进行参数校验？老鸟们都是这么玩的！ 3. SpringBoot 如何生成接口文档，老鸟们都这么玩的！ 4. SpringBoot 如何进行对象复制，老鸟们都这么玩的！ 5. SpringBoot 生成接口文档，我用smart-doc 6. SpringBoot
springboot中使用异步的常用两种方式及其比较
万米高空的博客
01-07 2387
一般对于业务复杂的流程，会有一些处理逻辑不需要及时返回，甚至不需要返回值，但是如果充斥在主流程中，占用大量时间来处理，就可以通过异步的方式来优化。 实现异步的常用方法远不止两种，但是个人经验常用的，好用的，这里我就说两种，最好用的是第二种。 spring的注解方式@Async org.springframework.scheduling.annotation.Async jdk1...
springboot实现定时任务不同任务异步执行，同一任务同步执行
zsj777的专栏
05-25 2466
Springboot @Scheduled 默认是单线程的， 也就是说当我们定义了多个定时任务时，如果有本应该是相同时间触发的定时任务， 会进行排队， 如果某个定时任务执行时间过长， 就会导致其他定时并未按照设置时间来触发执行。 异步任务可以部分解决这个问题， 在定时任务上再加上@Asyns注解，定时任务就会被作为异步任务多线程执行。 但是异步任务同样存在一个问题，如果任务执行顺序对结果没有影响，则可以用异步任务解决。但是如果同样的任务必须同步执行，但又不希望不同的定时任务之间也排队等待，则可以通过一
springboot带有进度条的上传功能完整实例
08-25
主要介绍了springboot带有进度条的上传功能,结合完整实例形式分析了springboot带进度条上传的原理、实现步骤与相关操作技巧,需要的朋友可以参考下
详解SpringBoot中异步请求和异步调用(看完这一篇就够了)
08-26
主要介绍了SpringBoot中异步请求和异步调用问题，非常不错，具有一定的参考借鉴价值,需要的朋友可以参考下
Java多线程之定时任务 以及 SpringBoot多线程实现定时任务——异步任务
03-12
1. SpringBoot 自定义线程池以及多线程间的异步调用（@Async、@EnableAsync） 2.Java多线程之定时任务 以及 SpringBoot多线程实现定时任务 3.@EnableScheduling 与 @Scheduled
详解springboot中使用异步的常用两种方式及其比较
08-25
主要介绍了详解springboot中使用异步的常用两种方式及其比较，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
springboot执行延时任务之DelayQueue的使用详解
08-25
DelayQueue是一个无界阻塞队列，只有在延迟期满时，才能从中提取元素。这篇文章主要介绍了springboot执行延时任务-DelayQueue的使用,需要的朋友可以参考下
springboot schedule 解决定时任务不执行的问题
08-25
主要介绍了springboot schedule 解决定时任务不执行的问题,本文给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
SpringBoot入门建站全系列（二十八）整合Kafka做日志监控
feiyangtianyao的专栏
09-20 2656
SpringBoot入门建站全系列（二十八）整合Kafka做日志监控 一、概述 Apache Kafka是一个分布式发布 - 订阅消息系统和一个强大的队列，可以处理大量的数据，并使您能够将消息从一个端点传递到另一个端点。 Kafka适合离线和在线消息消费。 Kafka消息保留在磁盘上，并在群集内复制以防止数据丢失。 Kafka构建在ZooKeeper同步服务之上。 它与Apache Storm和S...
SpringBoot入门建站全系列（二）Controller种类及映射处理详解
feiyangtianyao的专栏
04-26 1878
SpringBoot入门建站全系列（二）Controller种类及映射处理详解 Controller及Mapping其实不属于SpringBoot，SpringBoot只是个大杂烩的容器而已。Controller及Mapping分别在Spring的web和context包中存在着。 本文主要介绍Controller种类及映射处理详解，并针对不同的写法做出示例。 品茗IT-SpringBoot专题-...
SpringBoot入门建站全系列（三十四）使用Drools规则引擎做排班系统
feiyangtianyao的专栏
12-04 1718
SpringBoot入门建站全系列（三十四）使用Drools规则引擎做排班系统 一、概述 Drools 是用 Java 语言编写的开放源码规则引擎，使用 Rete 算法对所编写的规则求值。Drools 允许使用声明方式表达业务逻辑。可以使用非 XML 的本地语言编写规则，从而便于学习和理解。并且，还可以将 Java 代码直接嵌入到规则文件中，这令 Drools 的学习更加吸引人。 总结一句，Dro...
springboot异步执行延迟任务
最新发布
06-08
在Spring Boot中，可以使用@Async注解将一个方法标记为步执行。同时，结合ScheduledExecutorService可以实现延迟任务的异步执行。 首先，在Spring Boot中创建一个异步方法，需要在方法上添加@Async注解。例如： ```java @Service public class AsyncService { @Async public void doAsyncTask() { // 异步执行的任务 } } ``` 接下来，我们需要使用ScheduledExecutorService来实现延迟任务的异步执行。在Spring Boot中，可以使用@EnableScheduling注解开启定时任务的支持。例如： ```java @SpringBootApplication @EnableScheduling public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } ``` 然后，在需要执行延迟任务的地方，注入ScheduledExecutorService，并使用schedule方法来执行任务。例如： ```java @Service public class DelayService { @Autowired private ScheduledExecutorService executor; @Autowired private AsyncService asyncService; public void doDelayTask() { executor.schedule(() -> asyncService.doAsyncTask(), 10, TimeUnit.SECONDS); } } ``` 上面的例子中，我们注入了ScheduledExecutorService和AsyncService，然后使用schedule方法来执行异步任务。在这个例子中，异步任务将会在10秒后执行。 总之，结合@Async注解和ScheduledExecutorService可以实现Spring Boot中的异步执行和延迟任务。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值