spring中异步和线程池的使用

应用场景：

在java web开发中，有些接口处理的任务量非常大；而这些处理结果又不需要实时返回，那么我们线程异步的去做这些操作。

Spring为任务调度和异步方法提供了专有的注解解决方案。可以在方法上设置@Async注解，使方法被异步调用。调用者会在调用方法之后立即返回，而被调用方法的则执行是交给Spring的TaskExecutor来完成执行。

所以被注解的方法调用时，会在新的线程中执行，而调用他的方法则会在原线程中执行，这样可以避免阻塞；保证任务的实时性。

springBoot 中使用

spring提供的异步方法在springBoot中使用还是比较简单的，只需要做简单的注解配置就可以使用了；
此教程只针对异步方法，其他的配置全不做讲解。

1. 开启@Async注解的支持

我们首先创建一个简单的springBoot项目，在其启动类上添加@EnableAsync注解；

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. 编写异步方法配置类

MyAsyncConfigurer类实现了AsyncConfigurer接口，重写AsyncConfigurer接口的两个重要方法：

1. getAsyncExecutor：自定义线程池，若不重写或者返回null会使用默认的线程池。
2. getAsyncUncaughtExceptionHandler：捕捉IllegalArgumentException异常。

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler;
import org.springframework.scheduling.annotation.AsyncConfigurer;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.util.concurrent.Executor;

@Component
public class MyAsyncConfigurer implements AsyncConfigurer {

    private Logger logger = LoggerFactory.getLogger(MyAsyncConfigurer.class);
    
    /**
     * 自定义线程池，若不重写或者返回null，会使用默认的线程池。
     * @return	线程池对象
     */
    @Override
    public Executor getAsyncExecutor() {
        // 定义一个最大为20个线程数量的线程池
        ExecutorService service = Executors.newFixedThreadPool(20);
        return service;
    }

    /**
     * 捕捉IllegalArgumentException异常
     * @return
     */
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new MyAsyncExceptionHandler();
    }

    class MyAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {

        @Override
        public void handleUncaughtException(Throwable throwable, Method method, Object... objects) {
            logger.error("异常信息：" + throwable.getMessage());
            logger.error("方法名称：" + method.getName());
            logger.error("**********************************");
            for (Object param : objects) {
                logger.error("" + param);
            }
            logger.error("**********************************");
        }
    }
}

2. 异步方法的使用

1. 无参无返回值方法

异步方法代码：

@Async
public void simple() {
	try {
		Thread.sleep(3000);
        System.out.println("无参，无返回值，方法执行！！！");
    } catch (Exception e) {
        e.printStackTrace();
    }
}

调用异步方法：

@Autowired
private MyAsyncTest test;

@Test
public void contextLoads() throws Exception {
    test.simple();
    test.simple();
    test.simple();
    System.out.println("方法调用完成！！！");
    // 暂时不让主线程退出，等待子线程执行完成
    Thread.sleep(4000);
}

执行结果：

方法调用完成！！！
无参，无返回值，方法执行！！！
无参，无返回值，方法执行！！！
无参，无返回值，方法执行！！！

2. 有参无返回值方法

其实这种方法和无参无返回值的方法是一样的，只不过可以传入参数；这里我们让方法抛出指定的一场，看一下会有什么效果：

@Async
public void simple(String str) {
    System.out.println(str);
    throw new IllegalArgumentException("这是抛出的异常！！！");
}

调用方法：

@Autowired
private MyAsyncTest test;

@Test
public void contextLoads() throws Exception {
    test.simple("测试有参无返回值的方法！！！");
    System.out.println("方法调用完成！！！");
}

执行结果：

方法调用完成！！！
2019-03-19 20:46:09.447  INFO 7248 --- [       Thread-3] o.s.s.concurrent.ThreadPoolTaskExecutor  : Shutting down ExecutorService 'applicationTaskExecutor'
Disconnected from the target VM, address: '127.0.0.1:55126', transport: 'socket'
测试有参无返回值的方法！！！
2019-03-19 20:46:09.461 ERROR 7248 --- [         task-1] com.config.MyAsyncConfigurer             : 异常信息：这是抛出的异常！！！
2019-03-19 20:46:09.462 ERROR 7248 --- [         task-1] com.config.MyAsyncConfigurer             : 方法名称：simple
2019-03-19 20:46:09.462 ERROR 7248 --- [         task-1] com.config.MyAsyncConfigurer             : **********************************
2019-03-19 20:46:09.462 ERROR 7248 --- [         task-1] com.config.MyAsyncConfigurer             : 测试有参无返回值的方法！！！
2019-03-19 20:46:09.462 ERROR 7248 --- [         task-1] com.config.MyAsyncConfigurer             : **********************************

我们可以看出，在芳芳中抛出的IllegalArgumentException异常，MyAsyncConfigurer类中的getAsyncUncaughtExceptionHandler()捕捉，并打印了一些常用的信息。

3. 有参有返回值方法

异步方法：

@Async
public Future<String> simple1() {
    try {
        Thread.sleep(3000);
        System.out.println("simple1方法执行！！！");
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        return new AsyncResult<String>("这是simple1方法的返回值！！！");
    }
}

@Async
public Future<String> simple2() {
    try {
        Thread.sleep(5000);
        System.out.println("simple2方法执行！！！");
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        return new AsyncResult<String>("这是simple2方法的返回值！！！");
    }
}

调用：

@Autowired
private MyAsyncTest test;

@Test
public void contextLoads() throws Exception {
    long time1 = new Date().getTime();
    Future<String> res1 = test.simple1();
    Future<String> res2 = test.simple2();
    System.out.println("方法调用完成！！！");
    String msg1 = res1.get();
    String msg2 = res2.get();
    long time2 = new Date().getTime();
    System.out.println(msg1);
    System.out.println(msg2);
    System.out.println("调用时长：" + (time2 - time1) + "ms");
}

结果：

方法调用完成！！！
simple1方法执行！！！
simple2方法执行！！！
这是simple1方法的返回值！！！
这是simple2方法的返回值！！！
调用时长：5014ms

根据结果我们可以看出，当我们调用simple1()和simple2()方法后，层序已经在执行了，但是当我们使用Future的get()方法取值时，程序会产生阻塞，一直等到这个异步方法发执行结束后，才把值返回出来。

到这里异步方法的基本使用就已经完成了！！！

实现自己的线程池

回忆刚才的我们初始化了一个线程池，我们点进去看看它的源码吧！我们可以看到Executors.newFixedThreadPool()方法有很多重载，我们可以发现存在一个这样的方法

public static ExecutorService newFixedThreadPool(int nThreads, ThreadFactory threadFactory)

在这里我们看一下ThreadFactory是什么东西？点进去我们会发现这是一个接口；然后在网上找了一些资料，发现这是一个自定义先成池的接口；

我们简单实现一下，然后修改一下线程池的名称吧！

public class MyThreadFactory implements ThreadFactory {
    private static final AtomicInteger poolNumber = new AtomicInteger(1);
    private final ThreadGroup group;
    private final AtomicInteger threadNumber = new AtomicInteger(1);
    private final String namePrefix;

    public MyThreadFactory(String name) {
        SecurityManager s = System.getSecurityManager();
        group = (s != null) ? s.getThreadGroup() : Thread.currentThread().getThreadGroup();
        if (null == name || name.isEmpty()) {
            name = "pool";
        }
        namePrefix = name + "-" + poolNumber.getAndIncrement();
    }

    @Override
    public Thread newThread(Runnable r) {
        Thread t = new Thread(group, r, namePrefix + threadNumber.getAndIncrement(), 0);
        if (t.isDaemon())
            t.setDaemon(false);
        if (t.getPriority() != Thread.NORM_PRIORITY)
            t.setPriority(Thread.NORM_PRIORITY);
        return t;
    }
}

然后在创建线程池的时候，使用我们创建的新类就可以了

/**
 * 自定义线程池，若不重写或者返回null，会使用默认的线程池。
 * @return	线程池对象
 */
@Override
public Executor getAsyncExecutor() {
    ExecutorService service = Executors.newFixedThreadPool(20, new MyThreadFactory("ceshi"));
    return service;
}

这里结果就不展示了，因为这不是重点；只要在异步方法中打印日志，你就会发现线程池的名字被修改了。

在sprin 中实现异步调用功能

现在一般的开发方式都会集成在SpringBoot中，那么就要简单说一下不再springBoot中的配置文件配置方式吧！

我们只需要在配置问价中开启@Async注解即可；如下：

<task:annotation-driven executor="annotationExecutor" />
<!-- 支持 @Async 注解 -->
<task:executor id="annotationExecutor" pool-size="20"/>

然后我们就可以直接在方法上直接使用@Async注解，将方法设置为异步调用的方法了!!!