个人中心
文章发布
退出
作者热门文章
- Java锁的逻辑（结合对象头和ObjectMonitor）
- 还在用饼状图？来瞧瞧这些炫酷的百分比可视化新图形（附代码实现）⛵
- 自动注册实体类到EntityFrameworkCore上下文，并适配ABP及ABPVNext
- 基于Sklearn机器学习代码实战
34
4
1、简介 1）在方法上使用该@Async注解，申明该方法是一个异步任务； 2）在类上面使用该@Async注解，申明该类中的所有方法都是异步任务； 3） 方法上一旦标记了这个@Async注解，当其它线程调用这个方法时，就会开启一个新的子线程去异步处理该业务逻辑。 4）使用此注解的方法的类对象，必须是spring管理下的bean对象； 5） 要想使用异步任务，需要在主类上开启异步配置，即配置上@EnableAsync注解； 。
如下方式会使@Async失效 。
以Spring boot 为例，启动类中增加@EnableAsync:
@EnableAsync
@SpringBootApplication
public
class
ManageApplication {
//
...
}
@Component
public
class
MyAsyncTask {
@Async
public
void
asyncCpsItemImportTask(Long platformId, String jsonList){
//
...具体业务逻辑
}
}
@Async注解在使用时，如果不指定线程池的名称，则使用Spring默认的线程池，Spring默认的线程池为SimpleAsyncTaskExecutor.
该类型线程池的默认配置:
默认核心线程数：8
，
最大线程数：Integet.MAX_VALUE，
队列使用LinkedBlockingQueue，
容量是：Integet.MAX_VALUE，
空闲线程保留时间：60s，
线程池拒绝策略：AbortPolicy。
从最大线程数的配置上，相信你也看到问题了：并发情况下，会 无限 创建线程 、然后OOM、然后系统崩溃。。.
可以通过修改线程池默认配置，来解决上述问题； 。
spring:
task:
execution:
pool:
max
-size: 6
core
-size: 3
keep
-
alive: 3s
queue
-capacity: 1000
thread
-name-prefix: name
。
@Async注解，支持使用 自定义线程池 ，所以通过自定义线程池解决上述问题。 或者说，有时候、实际开发中就是要求你必修使用指定的线程池，@Async注解是支持的.
/**
*
@author
HWX
*/
@Configuration
@EnableAsync
public
class
ThreadPoolTaskConfig {
/*
默认情况下，在创建了线程池后，线程池中的线程数为0，当有任务来之后，就会创建一个线程去执行任务，
当线程池中的线程数目达到corePoolSize后，就会把到达的任务放到缓存队列当中；
当队列满了，就继续创建线程，当线程数量大于等于maxPoolSize后，开始使用拒绝策略拒绝
*/
/**
允许线程空闲时间（单位：默认为秒）
*/
private
static
final
int
KEEP_ALIVE_TIME = 60
;
/**
缓冲队列大小
*/
private
static
final
int
QUEUE_CAPACITY = 1000
;
/**
线程池名前缀
*/
private
static
final
String THREAD_NAME_PREFIX = "Async-Service-"
;
@Bean(
"taskExecutor")
//
bean的名称，默认为首字母小写的方法名
public
ThreadPoolTaskExecutor taskExecutor(){
//
获取当前机器CPU核数
int
cpuProcessors =
Runtime.getRuntime().availableProcessors();
if
(cpuProcessors == 0
) {
cpuProcessors
= 4
;
}
ThreadPoolTaskExecutor executor
=
new
ThreadPoolTaskExecutor();
executor.setCorePoolSize(cpuProcessors);
executor.setMaxPoolSize(cpuProcessors
+1
);
executor.setQueueCapacity(QUEUE_CAPACITY);
executor.setKeepAliveSeconds(KEEP_ALIVE_TIME);
executor.setThreadNamePrefix(THREAD_NAME_PREFIX);
//
线程池对拒绝任务的处理策略
//
CallerRunsPolicy：由调用线程（提交任务的线程）处理该任务
executor.setRejectedExecutionHandler(
new
ThreadPoolExecutor.CallerRunsPolicy());
//
初始化
executor.initialize();
return
executor;
}
}
使用 。
@Service
public
class
TranTest2Service {
Logger log
= LoggerFactory.getLogger(TranTest2Service.
class
);
//
发送提醒短信 1
@PostConstruct
//
加上该注解项目启动时就执行一次该方法
@Async("taskExecutor")
public
void
sendMessage1()
throws
InterruptedException {
log.info(
"发送短信方法---- 1 执行开始"
);
Thread.sleep(
5000);
//
模拟耗时
log.info("发送短信方法---- 1 执行结束"
);
}
//
发送提醒短信 2
@PostConstruct
//
加上该注解项目启动时就执行一次该方法
@Async("taskExecutor"
)
public
void
sendMessage2()
throws
InterruptedException {
log.info(
"发送短信方法---- 2 执行开始"
);
Thread.sleep(
2000);
//
模拟耗时
log.info("发送短信方法---- 2 执行结束"
);
}
}
@Async注解由于是异步执行的，在其进行数据库的操作之时，将无法控制事务管理。 解决办法：可以把 @Transactional注解放到内部的需要进行事务的方法上 ； 即将方法中对数据库的操作集中提取出来、放入一个方法中，对该方法加@Transactional注解进行事务控制 。
@Async的原理概括:
@Async 异步执行，是通过 Spring AOP 动态代理 的方式来实现的。Spring容器启动初始化bean时，判断类中是否使用了@Async注解，如果使用了则为其创建切入点和切入点处理器，根据切入点创建代理，在线程调用@Async注解标注的方法时，会调用代理，执行切入点处理器invoke方法，将方法的执行提交给线程池中的另外一个线程来处理，从而实现了异步执行.
所以，如果a方法调用它同类中的标注@Async的b方法，是不会异步执行的，因为从a方法进入调用的都是该类对象本身，不会进入代理类。因此， 相同类中的方法调用带@Async的方法是无法异步的，这种情况仍然是同步.
异步的业务逻辑处理场景 有两种：一个是不需要返回结果，另一种是需要接收返回结果.
不需要返回结果的比较简单，就不多说了.
需要接收返回结果的示例如下:
@Async("MyExecutor"
)
public
Future<Map<Long, List>>
queryMap(List ids) {
List
<> result =
businessService.queryMap(ids);
..............
Map
<Long, List> resultMap =
Maps.newHashMap();
...
return
new
AsyncResult<>
(resultMap);
}
调用异步方法的示例:
public
Map<Long, List> asyncProcess(List<BindDeviceDO> bindDevices,List<BindStaffDO>
bindStaffs, String dccId) {
Map
<Long, List> finalMap =
null
;
//
返回值：
Future<Map<Long, List>> asyncResult =
MyService.queryMap(ids);
try
{
finalMap
=
asyncResult.get();
}
catch
(Exception e) {
...
}
return
finalMap;
}
我个人觉得，异步方法不该设置返回值；因为调用异步方法的地方，还要等待返回结果的话，那就差不多又成了串行执行了，失去了异步的意义.
1、线程池本身也会消耗内存资源，所以我们要控制线程池的规模，防止它占用过多资源、进而影响项目运行； 2、为了统一规划资源，线程池尽量统一配置，即全项目尽量使用同一个线程池。 3、那么使用@Async，并自定义线程池，会全局公用吗?
我们做如下测试:
/**
application.yml配置*
*/
# 自定义线程池参数（用以@Async使用，可选）
execution:
pool:
core
-size: 3
queue
-capacity: 500
max
-size: 10
keep
-alive: 3
thread
-name-prefix: customize-th-
/**
线程池配置类*
*/
@Configuration
public
class
ExecutorConfig {
/**
* 核心线程
*/
@Value(
"${execution.pool.core-size}"
)
private
int
corePoolSize;
/**
* 队列容量
*/
@Value(
"${execution.pool.queue-capacity}"
)
private
int
queueCapacity;
/**
* 最大线程
*/
@Value(
"${execution.pool.max-size}"
)
private
int
maxPoolSize;
/**
* 保持时间
*/
@Value(
"${execution.pool.keep-alive}"
)
private
int
keepAliveSeconds;
/**
* 名称前缀
*/
@Value(
"${execution.pool.thread-name-prefix}"
)
private
String preFix;
@Bean(
"MyExecutor"
)
public
Executor myExecutor() {
ThreadPoolTaskExecutor executor
=
new
ThreadPoolTaskExecutor();
executor.setCorePoolSize(corePoolSize);
executor.setMaxPoolSize(maxPoolSize);
executor.setQueueCapacity(queueCapacity);
executor.setKeepAliveSeconds(keepAliveSeconds);
executor.setThreadNamePrefix(preFix);
executor.setRejectedExecutionHandler(
new
ThreadPoolExecutor.AbortPolicy());
executor.initialize();
return
executor;
}
}
/**
测试类A*
*/
@Service
public
class
TestServiceAImpl
implements
TestServiceA {
@Async(
"MyExecutor"
)
@Override
public
void
testMethod1() {
for
(
int
i = 0; i < 10; i++
) {
final
int
index =
i;
System.out.println(
"A类方法一的 " + index + " 被执行,线程名:" +
Thread.currentThread().getName());
try
{
Thread.sleep(
1000
);
}
catch
(InterruptedException e) {
e.printStackTrace();
}
}
}
@Async(
"MyExecutor"
)
@Override
public
void
testMethod2() {
for
(
int
i = 0; i < 10; i++
) {
final
int
index =
i;
System.out.println(
"A类方法二的 " + index + " 被执行,线程名:" +
Thread.currentThread().getName());
try
{
Thread.sleep(
1000
);
}
catch
(InterruptedException e) {
e.printStackTrace();
}
}
}
}
/**
测试类B*
*/
@Service
public
class
TestServiceBImpl
implements
TestServiceB {
@Async(
"MyExecutor"
)
@Override
public
void
testMethod1() {
for
(
int
i = 0; i < 10; i++
) {
final
int
index =
i;
System.out.println(
"B类方法一的 " + index + " 被执行,线程名:" +
Thread.currentThread().getName());
try
{
Thread.sleep(
1000
);
}
catch
(InterruptedException e) {
e.printStackTrace();
}
}
}
@Async(
"MyExecutor"
)
@Override
public
void
testMethod2() {
for
(
int
i = 0; i < 10; i++
) {
final
int
index =
i;
System.out.println(
"B类方法二的 " + index + " 被执行,线程名:" +
Thread.currentThread().getName());
try
{
Thread.sleep(
1000
);
}
catch
(InterruptedException e) {
e.printStackTrace();
}
}
}
}
@RestController
public
class
TestController{
@Autowired
private
TestServiceA testServiceA;
@Autowired
private
TestServiceB testServiceB;
/**
* 测试线程01
*/
@GetMapping(value
= "/threadTest"
)
public
void
threadTest01() {
System.out.println(
"【线程一】" + "group:"+ Thread.currentThread().getThreadGroup() + "; id:" +Thread.currentThread().getId()+"; name:"+
Thread.currentThread().getName());
testServiceA.testMethod1();
testServiceA.testMethod2();
testServiceB.testMethod1();
testServiceB.testMethod2();
}
}
。
2023-04-12 14:03:38.945 [http-nio-8085-exec-2] INFO o.a.c.c.C.[.[.[/] - [log,173] - Initializing Spring DispatcherServlet 'dispatcherServlet'
【线程一】group:java.lang.ThreadGroup[name
=main,maxpri=10]; id:85; name:http-nio-8085-exec-2
A类方法一的
0 被执行,线程名:customize-th-1
A类方法二的
0 被执行,线程名:customize-th-2
B类方法一的
0 被执行,线程名:customize-th-3
A类方法一的
1 被执行,线程名:customize-th-1
B类方法一的
1 被执行,线程名:customize-th-3
A类方法二的
1 被执行,线程名:customize-th-2
B类方法一的
2 被执行,线程名:customize-th-3
A类方法二的
2 被执行,线程名:customize-th-2
A类方法一的
2 被执行,线程名:customize-th-1
A类方法一的
3 被执行,线程名:customize-th-1
A类方法二的
3 被执行,线程名:customize-th-2
B类方法一的
3 被执行,线程名:customize-th-3
A类方法二的
4 被执行,线程名:customize-th-2
A类方法一的
4 被执行,线程名:customize-th-1
B类方法一的
4 被执行,线程名:customize-th-3
A类方法二的
5 被执行,线程名:customize-th-2
B类方法一的
5 被执行,线程名:customize-th-3
A类方法一的
5 被执行,线程名:customize-th-1
A类方法一的
6 被执行,线程名:customize-th-1
B类方法一的
6 被执行,线程名:customize-th-3
A类方法二的
6 被执行,线程名:customize-th-2
A类方法一的
7 被执行,线程名:customize-th-1
A类方法二的
7 被执行,线程名:customize-th-2
B类方法一的
7 被执行,线程名:customize-th-3
B类方法一的
8 被执行,线程名:customize-th-3
A类方法二的
8 被执行,线程名:customize-th-2
A类方法一的
8 被执行,线程名:customize-th-1
B类方法一的
9 被执行,线程名:customize-th-3
A类方法一的
9 被执行,线程名:customize-th-1
A类方法二的
9 被执行,线程名:customize-th-2
B类方法二的
0 被执行,线程名:customize-th-1
B类方法二的
1 被执行,线程名:customize-th-1
B类方法二的
2 被执行,线程名:customize-th-1
B类方法二的
3 被执行,线程名:customize-th-1
B类方法二的
4 被执行,线程名:customize-th-1
B类方法二的
5 被执行,线程名:customize-th-1
B类方法二的
6 被执行,线程名:customize-th-1
B类方法二的
7 被执行,线程名:customize-th-1
B类方法二的
8 被执行,线程名:customize-th-1
B类方法二的
9 被执行,线程名:customize-th-1
。
【分析】 从结果可以看到，A类、B类的方法交替执行，但是他们的线程都来自同一个线程池“customize-th-”、也就是我自己配置的线程池。 不仅如此，它们还遵循我对线程池的配置（核心线程数3），每当正在运行的线程满3，不论是A类还是B类、接下来的任务就先放入队列，等有空余线程再执行。 从以上两点可以确认，A类和B类用的是同一个线程池 ，@Async注解使用自定义线程池异步执行任务，只要在注解后添加线程池配置名称@Async(“MyExecutor”)、就可以实现整个项目公用同一个线程池.
最后此篇关于@Async注解详解以及可能遇到的各种问题的文章就讲到这里了,如果你想了解更多关于@Async注解详解以及可能遇到的各种问题的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。
34
4
0
我有带皮肤的 DNN。我的 head 标签有 runat="server"所以我尝试在 head 标签内添加一个标签 "> 在后面的代码中，我在属性中设置了 var GoogleAPIkey。问题是它
我在 Node.JS 中有一个导出模块 exports.doSomethingImportant= function(req, res) { var id = req.params.id; Demo.
我是 F# 的新手，我一直在阅读 F# for Fun and Profit。在为什么使用 F#？ 系列中，有一个 post描述异步代码。我遇到了 Async.StartChild函数，我不明白为什么
File 中有一堆相当方便的方法类，如 ReadAll***/WriteAll***/AppendAll***。 我遇到过很多情况，当我需要它们的异步对应物时，但它们根本不存在。 为什么？有什么陷阱吗
我最近开始做一个 Node 项目，并且一直在使用 async 库。我有点困惑哪个选项会更快。在某些数据上使用 async.map 并获取其结果，或使用 async.each 迭代一组用户并将他们的相应
您好，我正在试用 Springs 异步执行器，发现您可以使用 @Async。我想知道是否有可能在 @Async 中使用 @Async，要求是需要将任务委托(delegate)给 @Async 方法在第
我需要支持取消一个函数，该函数返回一个可以在启动后取消的对象。在我的例子中，requester 类位于我无法修改的第 3 方库中。 actor MyActor { ... func d
假设 asyncSendMsg不返回任何内容，我想在另一个异步块中启动它，但不等待它完成，这之间有什么区别: async { //(...async stuff...) for msg
我想用 Mocha 测试异步代码. 我跟着这个教程testing-promises-with-mocha .最后，它说最好的方法是 async/await。 以下是我的代码，我打算将 setTimeo
正如我有限(甚至错误)的理解，Async.StartImmediate 和 Async.RunSynchronously 在当前线程上启动异步计算。那么这两个功能究竟有什么区别呢？谁能帮忙解释一下？
我有一行使用await fetch() 的代码。我正在使用一些调用 eval("await fetch ...etc...") 的脚本注入(inject)，但问题是 await 在执行时不会执行从ev
我正在尝试使用 nodeJS 构建一个网络抓取工具，它在网站的 HTML 中搜索图像，缓存图像源 URL，然后搜索最大尺寸的图像。 我遇到的问题是 deliverLargestImage() 在循环遍
我想结合使用 async.each 和 async.series，但得到了意想不到的结果。 async.each([1, 2], function(item, nloop) { async.s
我的代码有问题吗？我使用 async.eachSeries 但我的结果总是抛出 undefined。 这里是我的代码: async.eachSeries([1,2,3], function(data,
我想在 trait 中编写异步函数，但是因为 async fn in traits 还不被支持，我试图找到等效的方法接口(interface)。这是我在 Rust nightly (2019-01-0
async setMyPhotos() { const newPhotos = await Promise.all(newPhotoPromises); someOtherPromise();
async.js 中 async.each 与 async.every 的区别？似乎两者都相同，只是 async.every 返回结果。纠正我，我错了。 最佳答案 每个异步 .each(coll, i
我正在尝试对一组项目运行 async.each。 对于每个项目，我想运行一个 async.waterfall。请参阅下面的代码。 var ids = [1, 2]; async.each(ids,
我的目标是测试 API 调用，将延迟考虑在内。我的灵感来自 this post . 我设计了一个沙箱，其中模拟 API 需要 1000 毫秒来响应和更改全局变量 result 的值。测试检查 500
async.each 是否作为异步数组迭代工作？ async.eachSeries 是否作为同步数组迭代工作？(它实际上等待响应) 我问这些是因为两者都有回调，但 async.each 的工作方式类似
我是一名优秀的程序员,十分优秀！