SpringBoot使用多线程很简单，首先我们要在配置类中增加@EnableAsync注解，然后在需要执行的方法上加@Async注解表明该方法是个异步方法，如果加在类级别上，则表明类所有的方法都是异步方法。

@Configuration
@EnableAsync  // 启用异步任务
public class AsyncConfiguration {
    // 声明一个线程池(并指定线程池的名字)
    @Bean("taskExecutor")
    public Executor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        //核心线程数5：线程池创建时候初始化的线程数
        executor.setCorePoolSize(5);
        //最大线程数50：线程池最大的线程数，只有在缓冲队列满了之后才会申请超过核心线程数的线程
        executor.setMaxPoolSize(50);
        //缓冲队列500：用来缓冲执行任务的队列
        executor.setQueueCapacity(500);
        //允许线程的空闲时间60秒：当超过了核心线程出之外的线程在空闲时间到达之后会被销毁
        executor.setKeepAliveSeconds(60);
        //线程池名的前缀：设置好了之后可以方便我们定位处理任务所在的线程池
        executor.setThreadNamePrefix("Async-");
        executor.initialize();
        return executor;
    }
}

    @Async("taskExecutor")
    public CompletableFuture<String> addById() throws InterruptedException {
        TestVo testVo = testDao.findNewList(); //取出当前最新一条数据
        Integer num = testVo.getNum();
        System.out.print("-----------------当前数字:" + num +"-----------------------n");
        testVo.setNum(num + 1);
        testDao.add(testVo);
        Thread.sleep(1000L);
        return CompletableFuture.completedFuture("success");
    }

我们使用累加某个字段的方式来检测是否启动的线程处理

    public void threadTest() throws InterruptedException {
        long start = System.currentTimeMillis();
        System.out.print("-----------------当前时间:" +start +"-----------------------n");

        CompletableFuture<String> task1 =testService.addById();
        CompletableFuture<String> task2 =testService.addById();
        CompletableFuture<String> task3 =testService.addById();
        //join() 的作用：让“主线程”等待“子线程”结束之后才能继续运行
        CompletableFuture.allOf(task1,task2,task3).join();
        float exc = (float)(System.currentTimeMillis() - start)/1000;
        System.out.print("-----------------更新结束，耗时"+exc+"秒n");
    }

上面的结果在控制台输出：

我们可以看到，一共启动了三个线程，总共耗时为1.315秒，所以线程执行是成功的。

注意
我们知道关键字synchronized可以保证在同一时刻，只有一个线程可以执行某个方法或某个代码块，同时synchronized可以保证一个线程的变化可见，那么如果我们把上述方法加上synchronized关键字会有什么结果呢？话不多说，我们检测一下看看：

    @Async("taskExecutor")
    public synchronized CompletableFuture<String> addById() throws InterruptedException {
        TestVo testVo = testDao.findNewList(); //取出当前最新一条数据
        Integer num = testVo.getNum();
        System.out.print("-----------------当前数字:" + num +"-----------------------n");
        testVo.setNum(num + 1);
        testDao.add(testVo);
        Thread.sleep(1000L);
        return CompletableFuture.completedFuture("success");
    }

执行结果为：

以上执行结果和我们的预期相符合，说明当我们使用了synchronized关键字以后，多个线程对同一个对象的同一个方法进行操作的时候，只有一个线程能够获得锁，其余线程只能等待前面的线程把锁释放之后才能获得锁。