实战Spring Boot 2.0系列(三)

如果反复执行单元测试可能会遇到各种不同的结果比如

1. 没有任何任务相关的输出
2. 有部分任务相关的输出
3. 乱序的任务相关的输出

原因是目前 doTaskOne()doTaskTwo()doTaskThree() 这三个方法已经 异步执行 了。主程序在 异步调用 之后主程序并不会理会这三个函数是否执行完成了由于没有其他需要执行的内容所以程序就 自动结束 了导致了 不完整 或是 没有输出任务 相关内容的情况。

注意@Async所修饰的函数不要定义为static类型这样异步调用不会生效。

为了让 doTaskOne()doTaskTwo()doTaskThree() 能正常结束假设我们需要统计一下三个任务 并发执行 共耗时多少这就需要等到上述三个函数都完成动用之后记录时间并计算结果。

那么我们如何判断上述三个 异步调用 是否已经执行完成呢我们需要使用 Future 来返回 异步调用 的 结果。

• 创建 AsyncCallBackTask 类声明 doTaskoneCallback()doTaskTwoCallback()doTaskThreeCallback() 三个方法对原有的三个方法进行包装。

@Component
public class AsyncCallBackTask extends AbstractTask {
    @Async
    public Future doTaskOneCallback() throws Exception {
 super.doTaskOne();
 return new AsyncResult<>("任务一完成");
    }

    @Async
    public Future doTaskTwoCallback() throws Exception {
 super.doTaskTwo();
 return new AsyncResult<>("任务二完成");
    }

    @Async
    public Future doTaskThreeCallback() throws Exception {
 super.doTaskThree();
 return new AsyncResult<>("任务三完成");
    }
}

@RunWith(SpringRunner.class)
@SpringBootTest
public class AsyncCallBackTaskTest {
    @Autowired
    private AsyncCallBackTask task;

    @Test
    public void testAsyncCallbackTask() throws Exception {
 long start = currentTimeMillis();
 Future task1 = task.doTaskOneCallback();
 Future task2 = task.doTaskTwoCallback();
 Future task3 = task.doTaskThreeCallback();

 // 三个任务都调用完成退出循环等待
 while (!task1.isDone() || !task2.isDone() || !task3.isDone()) {
     sleep(1000);
 }

 long end = currentTimeMillis();
 out.println("任务全部完成总耗时" + (end - start) + "毫秒");
    }
}

开始做任务一
开始做任务三
开始做任务二
完成任务二耗时4882毫秒
完成任务三耗时6484毫秒
完成任务一耗时8748毫秒
任务全部完成总耗时9043毫秒

@Configuration
public class TaskConfiguration {
    @Bean("taskExecutor")
    public Executor taskExecutor() {
 ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
 executor.setCorePoolSize(10);
 executor.setMaxPoolSize(20);
 executor.setQueueCapacity(200);
 executor.setKeepAliveSeconds(60);
 executor.setThreadNamePrefix("taskExecutor-");
 executor.setRejectedExecutionHandler(new CallerRunsPolicy());
 return executor;
    }
}

@Component
public class AsyncExecutorTask extends AbstractTask {
    @Async("taskExecutor")
    public void doTaskOne() throws Exception {
 super.doTaskOne();
 out.println("任务一当前线程" + currentThread().getName());
    }

    @Async("taskExecutor")
    public void doTaskTwo() throws Exception {
 super.doTaskTwo();
 out.println("任务二当前线程" + currentThread().getName());
    }

    @Async("taskExecutor")
    public void doTaskThree() throws Exception {
 super.doTaskThree();
 out.println("任务三当前线程" + currentThread().getName());
    }
}

@RunWith(SpringRunner.class)
@SpringBootTest
public class AsyncExecutorTaskTest {
    @Autowired
    private AsyncExecutorTask task;

    @Test
    public void testAsyncExecutorTask() throws Exception {
 task.doTaskOne();
 task.doTaskTwo();
 task.doTaskThree();

 sleep(30 * 1000L);
    }
}

开始做任务一
开始做任务三
开始做任务二
完成任务二耗时3905毫秒
任务二当前线程taskExecutor-2
完成任务一耗时6184毫秒
任务一当前线程taskExecutor-1
完成任务三耗时9737毫秒
任务三当前线程taskExecutor-3

@Bean("taskExecutor")
public Executor taskExecutor() {
    ThreadPoolTaskScheduler executor = new ThreadPoolTaskScheduler();
    executor.setPoolSize(20);
    executor.setThreadNamePrefix("taskExecutor-");
    executor.setWaitForTasksToCompleteOnShutdown(true);
    executor.setAwaitTerminationSeconds(60);
    return executor;
}