58SpringAOP异步操作

异步场景分析

​ 在开发系统的过程中，通常会考虑到系统的性能问题，提升系统性能的一个重要思想就是“串行”改“并行”。

假如我们在一个线程中进行操作多个业务的时候,这样的话线程就会不停的调度,假如有一个业务中途被挂起啦,那么其他的业务也只能等待,知道被挂起的业务重新获得资源,可以运行.这样的话就给客户带来了卡顿的不好体验,当然我们可以在执行的业务上手动 new Thread,开启一个线程,但是这样的话,每次访问都会创建新的线程,如果是高并发的情况下,就会造成内存溢出,系统崩溃.为了更好的解决这个问题,spring 中提供了异步注解@Async

Spring 业务的异步实现

启动异步配置

​ 在基于注解方式的配置中，借助@EnableAsync注解进行异步启动声明，Spring Boot版的项目中，将@EnableAsync注解应用到启动类上

示例代码:

package com.cy;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;
@EnableAsync//spring容器启动时会创建线程池
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Spring中@Async注解应用

在我们需要执行的业务方法上使用@Async注解进行异步声明

@Async //使用此注解的描述的方法会运行在由spring框架提供的一个线程中
@Override
public void saveObject(SysLog sysLog) {
    sysLogDao.insertObject(sysLog);

}

如果需要获取业务层异步方法的执行结果,那么返回值必须通过Future 进行接收,返回的时候使用new AsyncResult

实例代码:

@Transactional(propagation = Propagation.REQUIRES_NEW)
@Async
@Override
public Future saveObject(SysLog entity) {
    int rows=sysLogDao.insertObject(entity);
    //try{Thread.sleep(5000);}catch(Exception e) {}
    return new AsyncResult(rows);
}
//，AsyncResult对象可以对异步方法的执行结果进行封装，假如外界需要异步方法结果时，可以通过Future对象的get方法获取结果。

说明：对于@Async注解默认会基于ThreadPoolTaskExecutor对象获取工作线程，然后调用由@Async描述的方法，让方法运行于一个工作线程，以实现异步操作。但是假如系统中的默认拒绝处理策略,任务执行过程的异常处理不能满足我们自身业务需求的话,我可以对异步线程池进行自定义.(SpringBoot中默认的异步配置可以参考自动配置对象TaskExecutionAutoConfiguration).

spring框架连接池简易配置

task:
    execution:
      pool:
        core-size: 10 #核心线程数，当池中线程数没达到core-size时，每来一个请求都创建一个新的线程
        queue-capacity: 256 #队列容量，当核心线程都在忙，再来新的任务，会将任务放到队列
        max-size: 128 #当核心线程都在忙，队列也满了，再来新的任务，此时会创建新的线程，直到达到maxSize
        keep-alive: 60 #当任务高峰过后，有些线程会空闲下来，这空闲现线程达到一定的时间会被释放。
        allow-core-thread-timeout: false
      thread-name-prefix: service-task- 

对于线程池配置参数的含义,可以通过ThreadPoolExecutor对象进行分析

ThreadPoolExecutor

ThreadPoolExecutor提供了四个构造函数,最后都会归结于下面这个构造方法：

 public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue workQueue,
                              ThreadFactory threadFactory,
                              RejectedExecutionHandler handler) {}

参数的意义如下：

• corePoolSize：该线程池中核心线程数最大值
• maximumPoolSize： 该线程池中线程总数最大值
• keepAliveTime：该线程池中非核心线程闲置超时时长
• unit：keepAliveTime的单位
• workQueue：阻塞队列BlockingQueue，维护着等待执行的Runnable对象
• threadFactory：创建线程的接口，需要实现他的Thread newThread(Runnable r)方法。
• RejectedExecutionHandler：饱和策略，最大线程和工作队列容量且已经饱和时execute方法都将调用RejectedExecutionHandler 。

大概的流程图:

大致的流程描述为:

• 向线程池中添加任务，当任务数量少于corePoolSize时，会自动创建thead来处理这些任务；
• 当添加任务数大于corePoolSize且少于maximmPoolSize时，不在创建线程，而是将这些任务放到阻塞队列中，等待被执行；
• 接上面2的条件，且当阻塞队列满了之后，继续创建thread,从而加速处理阻塞队列；
• 当添加任务大于maximmPoolSize时，根据饱和策略决定是否容许继续向线程池中添加任务，默认的饱和策略是AbortPolicy（直接丢弃）

线程池中使用的阻塞队列

ArrayBlockingQueue：基于数组结构的有界阻塞队列，构造函数一定要传大小，FIFO（先进先出）；
LinkedBlockingQueue：***，默认大小65536（Integer.MAX_VALUE），当大量请求任务时，容易造成内存耗尽。
SynchronousQueue：同步队列，是一个特殊的BlockingQueue，它没有容量（这是因为在SynchronousQueue中，插入将等待另一个线程的删除操作，反之亦然）。具体可以参考：《Java SynchronousQueue Examples（译）》
PriorityBlockingQueue: 优先队列，***。
DelayedWorkQueue：这个队列接收到任务时，首先先入队，只有达到了指定的延时时间，才会执行任务

阻塞队列常见的方法

常见四种线程池

• newCachedThreadPool
• newFixedThreadPool
• newSingleThreadExecutor
• newScheduledThreadPool

它们通过Executors以静态方法的方式直接调用，实质上是它们最终调用的是ThreadPoolExecutor的构造方法

转载自:https://baijiahao.baidu.com/s?id=1638752286286006421&wfr=spider&for=pc