SpringBoot 使用线程池

1、创建线程池

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

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

@EnableAsync
@Configuration
public class ExecutorConfig {

	// 获取服务器的 cpu 个数
	private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();

    @Bean("taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        // 核心线程数
        executor.setCorePoolSize(CPU_COUNT * 2);
        // 最大线程数 (核心线程数 + 空闲线程数)
        executor.setMaxPoolSize(CPU_COUNT * 4);
        // 空闲线程生存时间 (生存时间内没有新任务，此线程资源会释放)
        executor.setKeepAliveSeconds(50);
        // 阻塞队列大小，当没有主线程空闲时，新任务会加入阻塞队列排队，队列满了会创建非核心线程（空闲线程）处理任务
        executor.setQueueCapacity(5000);
        // 线程名前缀
        executor.setThreadNamePrefix("");
		// 设置拒绝策略
		// AbortPolicy 	          ->    默认策略，如果阻塞队列满了丢掉这个任务并且抛出 RejectedExecutionException 异常
		// DiscardPolicy          ->    如果阻塞队列满了，会直接丢掉这个任务并且不会有任何异常
		// DiscardOldestPolicy    ->	如果阻塞队列满了，会将最早进入队列的任务删掉腾出空间，再尝试加入队列
		// CallerRunsPolicy       ->	如果添加到线程池失败，那么主线程会自己去执行该任务，不会等待线程池中的线程去执行
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        // 等待所有任务结束后再关闭线程池
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.initialize();
        return executor;
    }
}

2、业务方法添加 @Async 注解

import org.springframework.scheduling.annotation.Async;
import org.springframework.scheduling.annotation.AsyncResult;
import org.springframework.stereotype.Service;

import java.util.concurrent.Future;
import java.util.concurrent.atomic.AtomicInteger;

@Service
public class TestServiceImpl {

    public static volatile AtomicInteger i = new AtomicInteger(0);

    /**
     * 无返回结果
     */
    @Async("taskExecutor")
    public void test() {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("当前第" + i.incrementAndGet() + "次执行");
    }
    

    /**
     * 有返回结果
     */
    @Async("taskExecutor")
    public Future<String> test2() {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new AsyncResult("当前第" + i.incrementAndGet() + "次执行");
    }
}

3、测试

import com.meiya.engineScheduling.config.TestServiceImpl;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

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

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class ApplicationTest {

    @Autowired
    private TestServiceImpl testServiceImpl;

    @Test
    public void test() {
        TestServiceImpl.i = new AtomicInteger(0);
        for (int i = 0; i < 20; i++) {
            System.out.println("第" + (i + 1) + "个任务加入队列");
            testServiceImpl.test();
        }
        System.out.println("已全部加入队列");
    }

    
    @Test
    public void test2() throws InterruptedException, ExecutionException {
        TestServiceImpl.i = new AtomicInteger(0);
        for (int i = 0; i < 20; i++) {
            System.out.println("第" + (i + 1) + "个任务加入队列");
            Future<String> future = testServiceImpl.test2();
            // () -> 等待任务完成，获取执行结果，可能会有阻塞
            System.out.println(future.get());
        }
        System.out.println("已全部加入队列");
    }
}

4、注解失效原因

1. 注解的方法必须是 public 方法
2. 方法一定要从另一个类中调用，也就是从类的外部调用，类的内部调用是无效的。
   因为 @Async 注解的实现都是基于 AOP 动态代理，所以内部调用失效的原因是由于调用方法的是对象本身而不是代理对象，没有经过 Spring 容器
3. 异步方法使用注解 @Async 的返回值只能为 void 或者 Future