springboot-day8-分布式异步执行

一 概述

1.1 场景描述

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

1.2 同步执行的案例

1.2.1.启动类

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

1.2.3.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;
}

}

1.2.4.service层

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

1.2.5实现层

@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));
    }
}

1.2.6 执行结果

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

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

二.异步执行案例

2.1 异步执行配置步骤

                    1.启动类里面使用@EnableAsync注解开启功能，自动扫描
                    2.定义异步任务类并使用@Component标记组件被容器扫描,异步方法加上@Async
            注意点：
                1）要把异步任务封装到类里面，不能直接写到Controller

                2）增加Future<String> 返回结果 AsyncResult<String>("xxxxxx");  

                3）如果需要拿到结果 需要判断全部的 task.isDone()

2.2 异步执行案例

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

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

2.2.2 controller

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

@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()){
    while(true){
       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.2.3.service

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

2.2.4.实现类

@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));
    }
}

2.2.5 执行结果

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

页面：

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