AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

并发编程线程池以及 @Async 注解的使用

2022-04-25 324
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 并发编程线程池以及 @Async 注解的使用

建议先看我另外一篇文章：并发编程使用了 线程池 ThreadPoolExecutor 程序性能有了质的突破

开发环境
  • SpringBoot 2.1.10.RELEASE
  • JDK 1.8
1：启动类添加@EnableAsync注解
package com.nobody;

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

@SpringBootApplication
@EnableAsync
public class Application {

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

}
2：线程池配置
package com.nobody.config;

import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolExecutor;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@Configuration
public class ExecutorConfig {

    public static final int CORE_POOL_SIZE = 5;

    public static final int MAX_POOL_SIZE = 10;

    public static final int QUEUE_CAPACITY = 100;

    @Bean("myExecutor")
    public Executor asyncServiceExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 核心线程数大小
        executor.setCorePoolSize(CORE_POOL_SIZE);
        // 最大线程数大小
        executor.setMaxPoolSize(MAX_POOL_SIZE);
        // 阻塞队列容量
        executor.setQueueCapacity(QUEUE_CAPACITY);
        // 线程名前缀
        executor.setThreadNamePrefix("myTask-");
        // rejectionPolicy：当queue达到maxSize并且此时maxPoolSize也达到最大值的时候，对于新任务的处理策略
        // CallerRunsPolicy：不在新线程中执行任务，而是交由调用者所在的线程来执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}
3：编写异步方法
package com.nobody.domain;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;

@Service
public class AsyncService {

    private static final Logger LOGGER = LoggerFactory.getLogger(AsyncService.class);

    // 简单版本
    @Async
    public void asyncTaskA() {
        LOGGER.info("asyncTaskA 异步方法执行.");
    }

    // 入参类型，此处将调用者(线程)的MDC信息传入，主要是保持日志输出时，两个线程有同样的traceId
    @Async
    public void asyncTaslB(Map<String, String> contextMap) {
        MDC.setContextMap(contextMap);
        LOGGER.info("asyncTaskB 异步方法执行.");
    }

    // 线程执行后计数器减1
    @Async
    public void asyncTaskC(CountDownLatch cdl) {
        LOGGER.info("asyncTaskC 异步方法执行.");
        try {
            TimeUnit.SECONDS.sleep(2);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        cdl.countDown();
    }

    // 有返回参数类型
    @Async
    public Future<String> asyncTaskD(String message) {
        LOGGER.info("asyncTaskD 异步方法执行.");
        return new AsyncResult<String>("@" + message);
    }

}
4：异步调用
package com.nobody.controller;

import java.util.concurrent.ExecutionException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;

import com.nobody.domain.AsyncService;

@RestController
@RequestMapping("demo")
public class DemoController {

    private static final Logger LOGGER = LoggerFactory.getLogger(DemoController.class);

    @Autowired
    private AsyncService asyncService;

    @GetMapping("test")
    public void test() throws InterruptedException, ExecutionException {

        asyncService.asyncTaskA();

        LOGGER.info("主线程执行...");

    }

}

输出结果：
在这里插入图片描述

package com.nobody.controller;

import java.util.UUID;
import java.util.concurrent.ExecutionException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
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;

import com.nobody.domain.AsyncService;

@RestController
@RequestMapping("demo")
public class DemoController {

    private static final Logger LOGGER = LoggerFactory.getLogger(DemoController.class);

    @Autowired
    private AsyncService asyncService;

    @GetMapping("test")
    public void test() throws InterruptedException, ExecutionException {

        MDC.put("traceId", UUID.randomUUID().toString().replaceFirst("-", ""));
        asyncService.asyncTaskB(MDC.getCopyOfContextMap());

        LOGGER.info("主线程执行...");

    }

}

输出结果：
在这里插入图片描述

package com.nobody.controller;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;

import com.nobody.domain.AsyncService;

@RestController
@RequestMapping("demo")
public class DemoController {

    private static final Logger LOGGER = LoggerFactory.getLogger(DemoController.class);

    @Autowired
    private AsyncService asyncService;

    @GetMapping("test")
    public void test() throws InterruptedException, ExecutionException {

        CountDownLatch cdl = new CountDownLatch(2);
        asyncService.asyncTaskC(cdl);
        asyncService.asyncTaskC(cdl);
        try {
            // 等等两个线程执行后，再继续下面的执行，如果超过5s则不等待
            cdl.await(5, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        LOGGER.info("主线程执行...");

    }

}

输出结果：
在这里插入图片描述

package com.nobody.controller;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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;

import com.nobody.domain.AsyncService;

@RestController
@RequestMapping("demo")
public class DemoController {

    private static final Logger LOGGER = LoggerFactory.getLogger(DemoController.class);

    @Autowired
    private AsyncService asyncService;

    @GetMapping("test")
    public void test() throws InterruptedException, ExecutionException {

        Future<String> future = asyncService.asyncTaskD("Mr.nobody");
        LOGGER.info("future result:" + future.get());

        LOGGER.info("主线程执行...");

    }

}

在这里插入图片描述

文章标签：
Java
关键词：
并发编程线程
线程@async
线程@async注解
线程注解
陈皮的JavaLib
目录
相关文章
Codelinghu
|
3月前
|
并行计算 Java 数据处理
SpringBoot高级并发实践：自定义线程池与@Async异步调用深度解析
SpringBoot高级并发实践：自定义线程池与@Async异步调用深度解析
Codelinghu
279 0
土木林森
|
5月前
|
Java 程序员 调度
【JAVA 并发秘籍】进程、线程、协程：揭秘并发编程的终极武器！
【8月更文挑战第25天】本文以问答形式深入探讨了并发编程中的核心概念——进程、线程与协程，并详细介绍了它们在Java中的应用。文章不仅解释了每个概念的基本原理及其差异，还提供了实用的示例代码，帮助读者理解如何在Java环境中实现这些并发机制。无论你是希望提高编程技能的专业开发者，还是准备技术面试的求职者，都能从本文获得有价值的见解。
土木林森
84 1
Java开发者
|
2月前
|
缓存 Java 开发者
Java多线程并发编程：同步机制与实践应用
本文深入探讨Java多线程中的同步机制，分析了多线程并发带来的数据不一致等问题，详细介绍了`synchronized`关键字、`ReentrantLock`显式锁及`ReentrantReadWriteLock`读写锁的应用，结合代码示例展示了如何有效解决竞态条件，提升程序性能与稳定性。
Java开发者
193 6
叫个什么名字
|
2月前
|
并行计算 数据处理 调度
Python中的并发编程：探索多线程与多进程的奥秘####
本文深入探讨了Python中并发编程的两种主要方式——多线程与多进程，通过对比分析它们的工作原理、适用场景及性能差异，揭示了在不同应用需求下如何合理选择并发模型。文章首先简述了并发编程的基本概念，随后详细阐述了Python中多线程与多进程的实现机制，包括GIL（全局解释器锁）对多线程的影响以及多进程的独立内存空间特性。最后，通过实例演示了如何在Python项目中有效利用多线程和多进程提升程序性能。 ####
叫个什么名字
63 5
Java开发者
|
2月前
|
设计模式 安全 Java
Java 多线程并发编程
Java多线程并发编程是指在Java程序中使用多个线程同时执行，以提高程序的运行效率和响应速度。通过合理管理和调度线程，可以充分利用多核处理器资源，实现高效的任务处理。本内容将介绍Java多线程的基础概念、实现方式及常见问题解决方法。
Java开发者
118 0
萝卜带泥
|
3月前
|
数据挖掘 程序员 调度
探索Python的并发编程：线程与进程的实战应用
【10月更文挑战第4天】 本文深入探讨了Python中实现并发编程的两种主要方式——线程和进程，通过对比分析它们的特点、适用场景以及在实际编程中的应用，为读者提供清晰的指导。同时，文章还介绍了一些高级并发模型如协程，并给出了性能优化的建议。
萝卜带泥
45 3
丰宝宝
|
4月前
|
负载均衡 Java 调度
探索Python的并发编程：线程与进程的比较与应用
本文旨在深入探讨Python中的并发编程，重点比较线程与进程的异同、适用场景及实现方法。通过分析GIL对线程并发的影响，以及进程间通信的成本，我们将揭示何时选择线程或进程更为合理。同时，文章将提供实用的代码示例，帮助读者更好地理解并运用这些概念，以提升多任务处理的效率和性能。
丰宝宝
73 3
游客7ofzsdfcat7ls
|
4月前
|
缓存 监控 Java
Java中的并发编程：理解并应用线程池
在Java的并发编程中，线程池是提高应用程序性能的关键工具。本文将深入探讨如何有效利用线程池来管理资源、提升效率和简化代码结构。我们将从基础概念出发，逐步介绍线程池的配置、使用场景以及最佳实践，帮助开发者更好地掌握并发编程的核心技巧。
游客7ofzsdfcat7ls
46 10
ssh1121
|
4月前
|
Java Spring
运行@Async注解的方法的线程池
自定义@Async注解线程池
ssh1121
195 3
游客moiomvrp3vyac2
|
4月前
|
并行计算 API 调度
探索Python中的并发编程：线程与进程的对比分析
【9月更文挑战第21天】本文深入探讨了Python中并发编程的核心概念，通过直观的代码示例和清晰的逻辑推理，引导读者理解线程与进程在解决并发问题时的不同应用场景。我们将从基础理论出发，逐步过渡到实际案例分析，旨在揭示Python并发模型的内在机制，并比较它们在执行效率、资源占用和适用场景方面的差异。文章不仅适合初学者构建并发编程的基础认识，同时也为有经验的开发者提供深度思考的视角。
游客moiomvrp3vyac2
34 0