前言
在软件开发中,异步执行是一种常见的编程方式,能够显著提升系统的性能和响应速度。本文将深入探讨Java中异步编程的八种实现方式,帮助开发者选择适合自己项目的异步方案。
一、引言
异步执行对于开发者来说并不陌生。在实际的开发过程中,很多场景都会使用到异步编程,例如发送短信、邮件等操作。相比同步执行,异步执行能够大大缩短请求链路的耗时,提升系统的性能和用户体验。
二、异步的八种实现方式
- 线程Thread使用Java线程来实现异步编程是最基础的方式之一。通过创建线程对象,可以让任务在独立的线程中执行,避免阻塞主线程。
- FutureJava的Future接口允许提交一个任务并返回一个异步结果。但是Future的局限性在于无法被动接收异步任务的计算结果,需要通过主动轮询或阻塞获取的方式来获取结果。
- 异步框架CompletableFutureCompletableFuture是Java 8中新增的异步编程工具,提供了更加便利的异步操作方式。它支持任务流的串联和组合,避免了传统Future的一些不足之处。
- Spring注解@AsyncSpring框架提供了@Async注解,可以用于标记异步方法。结合自定义线程池,可以实现灵活的异步任务调度和管理。
- Spring ApplicationEvent事件基于Spring的事件机制,可以实现异步事件的处理。通过定义事件和事件处理器,可以实现解耦合和异步执行。
- 消息队列使用消息队列作为异步通信的中间件,可以实现高效可靠的消息传递。常见的消息队列包括RabbitMQ、Kafka等。
- 第三方异步框架(如Hutool的ThreadUtil)第三方库提供了丰富的异步编程工具,例如Hutool的ThreadUtil类可以简化异步任务的执行。
- Guava异步Guava提供了ListenableFuture接口,可以监听Future的完成事件,无需手动等待。这种方式能够降低并发程序的复杂度。
三、什么是异步?
异步是指不同任务之间相互独立,可以同时进行而不互相等待的执行方式。异步编程能够提高系统的吞吐量和性能,是现代软件开发中不可或缺的技术之一。
四、异步编程示例
4.1 线程异步
public class AsyncThread extends Thread {
@Override
public void run() {
System.out.println("Current thread name:" + Thread.currentThread().getName() + " Send email success!");
}
public static void main(String[] args) {
AsyncThread asyncThread = new AsyncThread();
asyncThread.run();
}
}
当然如果每次都创建一个 Thread 线程,频繁的创建、销毁,浪费系统资源,我们可以采用线程池:<br>private ExecutorService executorService = Executors.newCachedThreadPool();<br><br>public void fun() {<br>executorService.submit(new Runnable() {<br>@Override<br>public void run() {<br>log.info("执行业务逻辑...");<br>}<br>});<br>}
可以将业务逻辑封装到 Runnable 或 Callable 中,交由线程池来执行。
4.2 Future异步
@Slf4j
public class FutureManager {
public String execute() throws Exception {
ExecutorService executor = Executors.newFixedThreadPool(1);
Future<String> future = executor.submit(new Callable<String>() {
@Override
public String call() throws Exception {
System.out.println(" --- task start --- ");
Thread.sleep(3000);
System.out.println(" --- task finish ---");
return "this is future execute final result!!!";
}
});
//这里需要返回值时会阻塞主线程
String result = future.get();
log.info("Future get result: {}", result);
return result;
}
@SneakyThrows
public static void main(String[] args) {
FutureManager manager = new FutureManager();
manager.execute();
}
}
输出结果:<br>--- task start ---<br>--- task finish ---<br>Future get result: this is future execute final result!!!
4.3 CompletableFuture实现异步
public class CompletableFutureCompose {
/**
* thenAccept子任务和父任务公用同一个线程
*/
@SneakyThrows
public static void thenRunAsync() {
CompletableFuture<Integer> cf1 = CompletableFuture.supplyAsync(() -> {
System.out.println(Thread.currentThread() + " cf1 do something....");
return 1;
});
CompletableFuture<Void> cf2 = cf1.thenRunAsync(() -> {
System.out.println(Thread.currentThread() + " cf2 do something...");
});
//等待任务1执行完成
System.out.println("cf1结果->" + cf1.get());
//等待任务2执行完成
System.out.println("cf2结果->" + cf2.get());
}
public static void main(String[] args) {
thenRunAsync();
}
}
我们不需要显式使用 ExecutorService,CompletableFuture 内部使用了ForkJoinPool 来处理异步任务,如果在某些业务场景我们想自定义自己的异步线程池也是可以的。
4.4 Spring的@Async异步
4.4.1 自定义异步线程池
/**
* 线程池参数配置,多个线程池实现线程池隔离,@Async注解,默认使用系统自定义线程池,可在项目中设置多个线程池,在异步调用的时候,指明需要调用的线程池名称,比如:@Async("taskName")
*
* @author: jacklin
* @since: 2021/5/18 11:44
**/
@EnableAsync
@Configuration
public class TaskPoolConfig {
/**
* 自定义线程池
*
* @author: jacklin
* @since: 2021/11/16 17:41
**/
@Bean("taskExecutor")
public Executor taskExecutor() {
//返回可用处理器的Java虚拟机的数量 12
int i = Runtime.getRuntime().availableProcessors();
System.out.println("系统最大线程数 : " + i);
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
//核心线程池大小
executor.setCorePoolSize(16);
//最大线程数
executor.setMaxPoolSize(20);
//配置队列容量,默认值为Integer.MAX_VALUE
executor.setQueueCapacity(99999);
//活跃时间
executor.setKeepAliveSeconds(60);
//线程名字前缀
executor.setThreadNamePrefix("asyncServiceExecutor -");
//设置此执行程序应该在关闭时阻止的最大秒数,以便在容器的其余部分继续关闭之前等待剩余的任务完成他们的执行
executor.setAwaitTerminationSeconds(60);
//等待所有的任务结束后再关闭线程池
executor.setWaitForTasksToCompleteOnShutdown(true);
return executor;
}
}
4.4.2 AsyncService
public interface AsyncService {
MessageResult sendSms(String callPrefix, String mobile, String actionType, String content);
MessageResult sendEmail(String email, String subject, String content);
}
@Slf4j
@Service
public class AsyncServiceImpl implements AsyncService {
@Autowired
private IMessageHandler mesageHandler;
@Override
@Async("taskExecutor")
public MessageResult sendSms(String callPrefix, String mobile, String actionType, String content) {
try {
Thread.sleep(1000);
mesageHandler.sendSms(callPrefix, mobile, actionType, content);
} catch (Exception e) {
log.error("发送短信异常 -> ", e)
}
}
@Override
@Async("taskExecutor")
public sendEmail(String email, String subject, String content) {
try {
Thread.sleep(1000);
mesageHandler.sendsendEmail(email, subject, content);
} catch (Exception e) {
log.error("发送email异常 -> ", e)
}
}
}
4.5 Spring ApplicationEvent事件实现异步
4.5.1 定义事件
public class AsyncSendEmailEvent extends ApplicationEvent {
/**
* 邮箱
**/
private String email;
/**
* 主题
**/
private String subject;
/**
* 内容
**/
private String content;
/**
* 接收者
**/
private String targetUserId;
}
4.5.2 定义事件处理器
@Slf4j
@Component
public class AsyncSendEmailEventHandler implements ApplicationListener<AsyncSendEmailEvent> {
@Autowired
private IMessageHandler mesageHandler;
@Async("taskExecutor")
@Override
public void onApplicationEvent(AsyncSendEmailEvent event) {
if (event == null) {
return;
}
String email = event.getEmail();
String subject = event.getSubject();
String content = event.getContent();
String targetUserId = event.getTargetUserId();
mesageHandler.sendsendEmailSms(email, subject, content, targerUserId);
}
}
4.6 消息队列
4.6.1 回调事件消息生产者
@Slf4j
@Component
public class CallbackProducer {
@Autowired
AmqpTemplate amqpTemplate;
public void sendCallbackMessage(CallbackDTO allbackDTO, final long delayTimes) {
log.info("生产者发送消息,callbackDTO,{}", callbackDTO);
amqpTemplate.convertAndSend(CallbackQueueEnum.QUEUE_GENSEE_CALLBACK.getExchange(), CallbackQueueEnum.QUEUE_GENSEE_CALLBACK.getRoutingKey(), JsonMapper.getInstance().toJson(genseeCallbackDTO), new MessagePostProcessor() {
@Override
public Message postProcessMessage(Message message) throws AmqpException {
//给消息设置延迟毫秒值,通过给消息设置x-delay头来设置消息从交换机发送到队列的延迟时间
message.getMessageProperties().setHeader("x-delay", delayTimes);
message.getMessageProperties().setCorrelationId(callbackDTO.getSdkId());
return message;
}
});
}
}
4.6.2 回调事件消息消费者
@Slf4j
@Component
@RabbitListener(queues = "message.callback", containerFactory = "rabbitListenerContainerFactory")
public class CallbackConsumer {
@Autowired
private IGlobalUserService globalUserService;
@RabbitHandler
public void handle(String json, Channel channel, @Headers Map<String, Object> map) throws Exception {
if (map.get("error") != null) {
//否认消息
channel.basicNack((Long) map.get(AmqpHeaders.DELIVERY_TAG), false, true);
return;
}
try {
CallbackDTO callbackDTO = JsonMapper.getInstance().fromJson(json, CallbackDTO.class);
//执行业务逻辑
globalUserService.execute(callbackDTO);
//消息消息成功手动确认,对应消息确认模式acknowledge-mode: manual
channel.basicAck((Long) map.get(AmqpHeaders.DELIVERY_TAG), false);
} catch (Exception e) {
log.error("回调失败 -> {}", e);
}
}
}
4.7 ThreadUtil异步工具类
@Slf4j
public class ThreadUtils {
public static void main(String[] args) {
for (int i = 0; i < 3; i++) {
ThreadUtil.execAsync(() -> {
ThreadLocalRandom threadLocalRandom = ThreadLocalRandom.current();
int number = threadLocalRandom.nextInt(20) + 1;
System.out.println(number);
});
log.info("当前第:" + i + "个线程");
}
log.info("task finish!");
}
}
4.8 Guava异步
ListeningExecutorService executorService = MoreExecutors.listeningDecorator(Executors.newCachedThreadPool());
final ListenableFuture<Integer> listenableFuture = executorService.submit(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
log.info("callable execute...")
TimeUnit.SECONDS.sleep(1);
return 1;
}
});
Futures.addCallback(listenableFuture, new FutureCallback<Integer>() {
@Override
public void onSuccess(Integer result) {
//成功执行...
System.out.println("Get listenable future's result with callback " + result);
}
@Override
public void onFailure(Throwable t) {
//异常情况处理...
t.printStackTrace();
}
});
五、总结
通过本文的介绍,我们详细了解了Java中异步编程的八种实现方式。选择合适的异步方案能够提高系统的性能和响应速度,希望本文能够帮助读者更好地理解和应用异步编程技术。
六、参考链接
- https://juejin.cn/post/7165147306688249870
- https://chencoding.top:8090
暂无评论内容