出自:

腾讯课堂 700多分钟干货实战Java多线程高并发高性能实战全集 , 我学习完了之后, 我给 老师在课上说的话做了个笔记,以及视频的内容,还有代码敲了一遍,然后添加了一些注释,把执行结果也整理了一下, 做了个笔记

概述

在微服务的实际开发过程中,经常会出现聚合服务调用多个原子服务的情形,核心中台等团队经常会出现这种技术场景.

1. 先调用原子服务CheckService1 \CheckService2\CheckService3 ,这三个服务没有什么依赖关系的,也就是说可以并行的调用,三个服务都是独立的.这三个服务调用各自的耗时是2.5秒 \1.8秒\1.5秒.
2. 当校验服务CheckService1\CheckService2\CheckService3都返回true的时候, 订单服务OrderService实现生成订单的功能,耗时0.5秒.
   ​

如果你是架构师,要求:

1. 请实现微服务的同步调用
2. 请实现微服务的并行调用
3. 统计1和2的耗时\比较性能.
   ​

微服务的同步调用和并行调用比较

同步调用是三个调用时间累加,并行调用是按照调用时间最长的计算.,
​

代码

代码地址

https://gitee.com/zjj19941/mutil-thread/tree/master/src/main/java/com/yrxy/thread/case13

Test

public class Test {
    public static void main(String[] args) throws Exception {
    	// 串行调用
        long t1=System.currentTimeMillis();
        System.out.println("begin to excute createSyncOrder");
        OrderService.createSyncOrder();
        System.out.println("end createSyncOrder , it has spent "+ (System.currentTimeMillis()-t1)+" ms");
        System.out.println("===========================================");
        // 并行调用
        long t2=System.currentTimeMillis();
        System.out.println("begin to excute createParrelOrder");
        OrderService.createParrelOrder();
        System.out.println("end createParrelOrder, it has spent "+ (System.currentTimeMillis()-t2)+" ms");
    }
}

OrderService

import java.util.concurrent.*;

public class OrderService {

    public static int createSyncOrder(){
        boolean flag1= CheckService1.check();
        boolean flag2=CheckService2.check();
        boolean flag3=CheckService3.check();
       if(true==flag1&&true==flag2&&true==flag3){
           createOrder();
           return 1;
       }
       return  0;
    }

    public static int createParrelOrder() throws Exception {
        int threadCount=3;
        ExecutorService executor = Executors.newFixedThreadPool(threadCount);
        CheckService1Callable  call1=new CheckService1Callable();
        Future<Boolean> future1 =executor.submit(call1);
        CheckService2Callable  call2=new CheckService2Callable();
        Future<Boolean> future2 =executor.submit(call2);
        CheckService3Callable  call3=new CheckService3Callable();
        Future<Boolean> future3=executor.submit(call3);
        // 如果三个都返回true才接着在,否则就不走了.
        if(true==future1.get()&&true==future2.get()&&true==future3.get()){
            System.out.println("true==future1.get()&&true==future2.get()&&true==future3.get()");
            createOrder();
         return  1;
        }
        executor.shutdown();
        return 0;
    }

     public static void createOrder(){
         try {
             //模拟生成订单的逻辑
             Thread.sleep(500);
             System.out.println("==finally，create Order==");
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
     }

}

CheckService1

public class CheckService1 {

   public static boolean  check(){
       boolean flag=true;
       try {
           //模拟执行逻辑
           Thread.sleep(2500);
           System.out.println("==CheckService1.check==");
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       return flag;
   }

}

CheckService1Callable

import java.util.concurrent.Callable;

public class CheckService1Callable  implements Callable<Boolean> {

    @Override
    public Boolean call() throws Exception {
        return CheckService1.check();
    }

}