线程池拒绝策略

先自定义一个线程池

@Configuration
class TaskPoolConfig  {
　　

//拒绝策略测试
    @Bean
    public Executor taskExecutor1() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(2);
        executor.setQueueCapacity(2);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("cwExecutor-1-");
        //AbortPolicy策略：默认策略，如果线程池队列满了丢掉这个任务并且抛出RejectedExecutionException异常。
//        org.springframework.core.task.TaskRejectedException: Executor [java.util.concurrent.ThreadPoolExecutor@5e6bbe63[Running, pool size = 2, active threads = 2, queued tasks = 2, completed tasks = 0]] did not accept task: java.util.concurrent.CompletableFuture$AsyncSupply@a11efe6
//        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.AbortPolicy());



        //DiscardPolicy策略：如果线程池队列满了，会直接丢掉这个任务并且不会有任何异常。
//        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardPolicy());

        //DiscardOldestPolicy策略：如果队列满了，会将最早进入队列的任务删掉腾出空间，再尝试加入队列。
//        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.DiscardOldestPolicy());

        //CallerRunsPolicy策略：如果添加到线程池失败，那么主线程会自己去执行该任务，不会等待线程池中的线程去执行。
//        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());

        //自定义策略：可以把任务存起来之后处理
        executor.setRejectedExecutionHandler(new RejectedExecutionHandler() {
            @Override
            public void rejectedExecution(Runnable r, ThreadPoolExecutor executor) {
                System.out.println("线程池满了");
            }
        });
        return executor;
    }

}

使用该线程池执行异步任务

@Component
public class AsyncTasks {
    public static Random random = new Random();
    private Logger logger = Logger.getLogger(getClass());

    @Async("taskExecutor1")
    public CompletableFuture<String> doTaskOne(String taskNo) throws Exception {
        logger.info("开始任务：" + taskNo);
        logger.info("任务"+taskNo+"的线程名：" + Thread.currentThread().getName());
        logger.info("任务"+taskNo+"的线程名：" + Thread.currentThread().getState());
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        logger.info("完成任务：" + taskNo + "，耗时：" + (end - start) + " 毫秒");
        return CompletableFuture.completedFuture("任务完成");
    }
}

异步任务测试

@SpringBootTest
public class PolicyTest {
    @Autowired
    private AsyncTasks asyncTasks;

    @Test
    public void test1() throws Exception {
        // 线程池配置：core-2,max-2,queue=2，可以容纳4个任务提交  不会报任何异常

        long start = System.currentTimeMillis();

        // 线程池1
        CompletableFuture<String> task1 = asyncTasks.doTaskOne("1");
        CompletableFuture<String> task2 = asyncTasks.doTaskOne("2");
        CompletableFuture<String> task3 = asyncTasks.doTaskOne("3");
        CompletableFuture<String> task4 = asyncTasks.doTaskOne("4");

        // 一起执行
        CompletableFuture.allOf(task1, task2, task3, task4).join();

        long end = System.currentTimeMillis();

        System.out.println("任务全部完成，总耗时：" + (end - start) + "毫秒");
    }

    @Test
    public void test2() throws Exception {
        // 线程池配置：core-2,max-2,queue=2，可以容纳4个任务提交, 同时5个任务提交测试

        long start = System.currentTimeMillis();

        // 线程池1
        CompletableFuture<String> task1 = asyncTasks.doTaskOne("1");
        CompletableFuture<String> task2 = asyncTasks.doTaskOne("2");
        CompletableFuture<String> task3 = asyncTasks.doTaskOne("3");
        CompletableFuture<String> task4 = asyncTasks.doTaskOne("4");
        CompletableFuture<String> task5 = asyncTasks.doTaskOne("5");

        // 一起执行
        try{
　　　　　　　　//get方法可以设置超时时间，超时会报异常，join方法会导致线程一直阻塞
            CompletableFuture.allOf(task1, task2, task3, task4, task5).get(30, TimeUnit.SECONDS);
        }catch (Exception e) {
            System.out.println("超时");
        }

        long end = System.currentTimeMillis();

        System.out.println("任务全部完成，总耗时：" + (end - start) + "毫秒");
    }
}