业务场景描述：一个网站，需要用户注册--->发送短信----->发送邮件，这三个步骤，顺序执行。这种方式为同步方式

一.同步执行的代码如下：

1.启动类：

@SpringBootApplication
//@EnableAsync   //开启异步调用
public class App 
{
    public static void main( String[] args )
    {
        SpringApplication.run(App.class, args);
        System.out.println( "Hello World!" );
    }
}

2.controller类：

package com.ljf.springboot.demos.sync.controller;

import com.ljf.springboot.demos.sync.service.TaskService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @className TaskController
 * @Description TODO
 * @Author liujianfu
 * @Date 2019/3/25 9:48
 * @Version 1.0
 **/

@RestController
@RequestMapping("/test")
public class TaskController {
@Autowired
private TaskService taskService;

@GetMapping(value="/v1")
public String zong() throws InterruptedException {
    long start=System.currentTimeMillis();
    taskService.registerUser();;
    taskService.sendEmail();
    taskService.sendMessage();
    long end=System.currentTimeMillis();
    String str="总耗时:"+(end-start);
   return str;
}

}

3.service层

public interface TaskService {
    public void registerUser() throws InterruptedException;
    public void sendEmail() throws InterruptedException;
    public void sendMessage() throws InterruptedException;
}

4.实现层：

@Service
public class TaskServiceImpl  implements  TaskService{

    @Override
    public void registerUser() throws InterruptedException {
        long  start=System.currentTimeMillis();
        Thread.sleep(1000);
        long  end=System.currentTimeMillis();
        System.out.println("注册用户消费:"+(end-start));

    }

    @Override
    public void sendEmail() throws InterruptedException {
        long  start=System.currentTimeMillis();
        Thread.sleep(2000);
        long  end=System.currentTimeMillis();
        System.out.println("发送邮件消费:"+(end-start));
    }

    @Override
    public void sendMessage() throws InterruptedException {
        long  start=System.currentTimeMillis();
        Thread.sleep(3000);
        long  end=System.currentTimeMillis();
        System.out.println("发送短信消费:"+(end-start));
    }
}

执行结果：

注册用户消费:1001
发送邮件消费:2000
发送短信消费:3001
页面查看：

可见是顺序执行的，总时间为三个方法的累积时间。

二.异步执行的代码如下：

1.在启动类中使用@EnableAsync注解开启功能，自动扫描

扫描二维码关注公众号，回复： 6091532 查看本文章

@SpringBootApplication
@EnableAsync   //开启异步调用
public class App
{
    public static void main( String[] args )
    {
        SpringApplication.run(App.class, args);
        System.out.println( "Hello World!" );
    }
}

2.定义异步任务类并使用@Compent标记组件被容器扫描，异步方法加上@Async
  1.要把异步任务封装到类里面，不能直接写到controller
  2.增加Future<String> 返回结果 AsyncResult<String>("返回结果")；
  3.如果需要拿到结果，需要判断全部的的task.isDone();

controller：

@RestController

@RequestMapping("/test")
public class TaskController {
@Autowired
private TaskService taskService;

@GetMapping(value="/v1")
public String zong() throws InterruptedException, ExecutionException {
    long start=System.currentTimeMillis();
    Future<String> s1 = taskService.registerUser();;
    Future<String> s2 = taskService.sendEmail();
    Future<String> s3 = taskService.sendMessage();
    while(!s1.isDone()||!s2.isDone()|| !s3.isDone()){
       if(s1.isDone()&&s2.isDone()&&s3.isDone()){
           break;
       }
    }
    System.out.println(s1.get());
    System.out.println(s2.get());
    System.out.println(s3.get());
    long end=System.currentTimeMillis();
    String str="总耗时:"+(end-start);
    System.out.println(str);

   return str;
}

}

2.service：

public interface TaskService {
    public Future<String> registerUser() throws InterruptedException;
    public Future<String> sendEmail() throws InterruptedException;
    public Future<String> sendMessage() throws InterruptedException;
}

3.实现类

@Service
@Component
public class TaskServiceImpl  implements  TaskService{

    @Override
    @Async
    public Future<String> registerUser() throws InterruptedException {
        long  start=System.currentTimeMillis();
        Thread.sleep(1000);
        long  end=System.currentTimeMillis();
        return new AsyncResult<String>("注册用户消费:"+(end-start));
    }

    @Override
    @Async
    public Future<String> sendEmail() throws InterruptedException {
        long  start=System.currentTimeMillis();
        Thread.sleep(2000);
        long  end=System.currentTimeMillis();
        return new AsyncResult<String>("发送邮件消费:"+(end-start));
    }

    @Override
    @Async
    public Future<String> sendMessage() throws InterruptedException {
        long  start=System.currentTimeMillis();
        Thread.sleep(3000);
        long  end=System.currentTimeMillis();
        return new AsyncResult<String>("发送短信消费:"+(end-start));
    }
}

执行结果：

注册用户消费:1000
发送邮件消费:2000
发送短信消费:3001
总耗时:3005

页面：

可见分布式异步执行，执行的总时间为3.005秒小于同步执行的时间（1+2+3）的执行时间