谷粒商城篇章6 ---- P193-P210 ---- 异步&线程池&商品详情【分布式高级篇三】
目录
1. 异步
1.1 初始化线程的 4 种方式
1.1.1 继承 Thread
1.1.2 实现 Runnable 接口
1.1.3 实现 Callable 接口 + FutureTask
1.1.4 线程池
1.1.5 以上 4 种方式总结：
1.2 线程池详解
1.2.1 初始化线程池的 2 种方式
1.2.1.1 使用 Executors 创建
1.2.1.2 使用 ThreadPoolExecutor 创建
1.2.1.2.1 ThreadPoolExecutor 线程池的七大参数
1.2.1.2.2 运行流程
1.2.1.2.3 线程池面试题
1.2.2 常见的 4 种线程池
1.2.3 使用线程池的好处
1.3 CompletableFuture异步编排
1.3.1 启动异步任务
1.3.1.1 runAsync没有返回值
1.3.1.2 supplyAsync有返回值
1.3.2 完成回调与异常感知
1.3.2.1 完成回调 whenComplete
1.3.2.2 异常感知 exceptionally
1.3.3 handle 最终处理
1.3.4 线程串行化
1.3.4.1 thenRunAsync
1.3.4.2 thenAcceptAsync
1.3.4.3 thenApplyAsync
1.3.5 两个任务组合 - 都要完成
1.3.5.1 runAfterBothAsync
1.3.5.2 thenAcceptBothAsync
1.3.5.3 thenCombineAsync
1.3.6 两个任务组合 - 一个完成
1.3.6.1 runAfterEitherAsync
1.3.6.2 acceptEitherAsync
1.3.6.3 applyToEitherAsync
1.3.7 多任务组合
1.3.7.1 allOf
1.3.7.2 anyOf
2. 商品详情
2.1 环境搭建
2.1.1 SwitchHosts增加配置
2.1.2 nginx配置
2.1.3 配置网关转发
2.1.4 商品详情页面搭建
2.1.5 模型抽取
2.1.6 商品详情的业务代码
2.1.6.1 controller层
2.1.6.2 service层
2.1.6.3 获取sku的图片信息
2.1.6.4 获取spu的规格参数
2.1.6.5 获取spu的销售属性组合
2.1.7 详情页渲染【P207-P209】
2.1.8 异步编排优化
2.1.8.1 自定义线程池
2.1.8.1.1 引入依赖
2.1.8.1.2 线程池属性配置类
2.1.8.1.3 配置文件中配置
2.1.8.1.4 自定义线程池
2.1.8.2 异步编排优化商品详情业务
2.1.8.2.1 controller层
2.1.8.2.2 service层
1. 异步
1.1 初始化线程的 4 种方式
1.1.1 继承 Thread
public class ThreadTest {
public static void main(String[] args) {
System.out.println("main...start...");
// 1. 继承Thread类
Thread01 thread01 = new Thread01();
thread01.start(); // 启动线程
System.out.println("main...end...");
}
public static class Thread01 extends Thread{
@Override
public void run() {
System.out.println("当前线程："+Thread.currentThread().getId());
int i = 10/2;
System.out.println("运行结果："+i);
}
}
}测试结果：
1.1.2 实现 Runnable 接口
public class ThreadTest {
public static void main(String[] args) {
System.out.println("main...start...");
// 1. 继承Thread类
//Thread01 thread01 = new Thread01();
//thread01.start(); // 启动线程
// 2. 实现Runnable接口
Runnable01 runnable01 = new Runnable01();
new Thread(runnable01).start();
System.out.println("main...end...");
}
public static class Thread01 extends Thread{
@Override
public void run() {
System.out.println("当前线程："+Thread.currentThread().getId());
int i = 10/2;
System.out.println("运行结果："+i);
}
}
public static class Runnable01 implements Runnable{
@Override
public void run() {
System.out.println("当前线程："+Thread.currentThread().getId());
int i = 10/2;
System.out.println("运行结果："+i);
}
}
}
1.1.3 实现 Callable 接口 + FutureTask
FutureTask的get()方法，阻塞式等待整个线程的执行完成，获取线程执行返回结果。
public class ThreadTest {
public static ExecutorService executorService = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println("main...start...");
// 1. 继承Thread类
//Thread01 thread01 = new Thread01();
//thread01.start(); // 启动线程
// 2. 实现Runnable接口
//Runnable01 runnable01 = new Runnable01();
//new Thread(runnable01).start();
// 3. 实现Callable接口+FutureTask （可以拿到返回结果，可以处理异常）
Callable01 callable01 = new Callable01();
FutureTask futureTask = new FutureTask<>(callable01);
new Thread(futureTask).start();
// 阻塞式等待整个线程执行完成，获取线程执行返回结果
Integer integer = futureTask.get();
System.out.println("main...end..."+integer );
}
public static class Thread01 extends Thread{
@Override
public void run() {
System.out.println("当前线程："+Thread.currentThread().getId());
int i = 10/2;
System.out.println("运行结果："+i);
}
}
public static class Runnable01 implements Runnable{
@Override
public void run() {
System.out.println("当前线程："+Thread.currentThread().getId());
int i = 10/2;
System.out.println("运行结果："+i);
}
}
public static class Callable01 implements Callable{
@Override
public Integer call() throws Exception {
System.out.println("当前线程："+Thread.currentThread().getId());
int i = 10/2;
System.out.println("运行结果："+i);
return i;
}
}
} 
注意：
Future可以获取异步执行结果；
FutureTask继承了Runnable接口。
1.1.4 线程池
public class ThreadTest {
public static ExecutorService executorService = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println("main...start...");
// 1. 继承Thread类
//Thread01 thread01 = new Thread01();
//thread01.start(); // 启动线程
// 2. 实现Runnable接口
//Runnable01 runnable01 = new Runnable01();
//new Thread(runnable01).start();
// 3. 实现Callable接口+FutureTask （可以拿到返回结果，可以处理异常）
//Callable01 callable01 = new Callable01();
//FutureTask futureTask = new FutureTask<>(callable01);
//new Thread(futureTask).start();
阻塞式等待整个线程执行完成，获取线程执行返回结果
//Integer integer = futureTask.get();
// 在以后的业务代码里面，以上三种启动线程的方式都不用，因为频繁的创建和销毁线程耗费系统资源。【将所有的多线程异步任务都交给线程池执行】
//new Thread(()-> System.out.println("hello")).start();
// 4. 线程池 给线程池直接提交业务
// 当前系统中池只有一两个（例如：核心业务/非核心业务），每个异步任务，提交给线程池让它自己去执行就行
executorService.execute(new Runnable01());
System.out.println("main...end...");
}
public static class Thread01 extends Thread{
@Override
public void run() {
System.out.println("当前线程："+Thread.currentThread().getId());
int i = 10/2;
System.out.println("运行结果："+i);
}
}
public static class Runnable01 implements Runnable{
@Override
public void run() {
System.out.println("当前线程："+Thread.currentThread().getId());
int i = 10/2;
System.out.println("运行结果："+i);
}
}
public static class Callable01 implements Callable{
@Override
public Integer call() throws Exception {
System.out.println("当前线程："+Thread.currentThread().getId());
int i = 10/2;
System.out.println("运行结果："+i);
return i;
}
}
}
1.1.5 以上 4 种方式总结：
区别：
1、2不能得到返回值；3可以获取返回值
1、2、3都不能控制资源
4可以控制资源，性能稳定注意：
1. 在以后的业务代码里面，以上三种启动线程的方式都不用，因为频繁的创建和销毁线程耗费系统资源，可能导致服务器资源耗尽。【将所有的多线程异步任务都交给线程池执行】
2. 当前系统中池只有一两个（例如：核心业务/非核心业务），每个异步任务，提交给线程池让它自己去执行就行
1.2 线程池详解
1.2.1 初始化线程池的 2 种方式
1.2.1.1 使用 Executors 创建
ExecutorService executorService = Executors.newFixedThreadPool(10);线程池执行任务的两种方式：
executorService.execute(new Runnable01());
Future submit = executorService.submit(new Runnable01());区别：
execute：参数只能是Runnable，没有返回值。
submit：参数可以是Runnable、Callable，返回值是Future。
1.2.1.2 使用 ThreadPoolExecutor 创建
ThreadPoolExecutor executor = new ThreadPoolExecutor(5,
200,
10,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(100000),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());1.2.1.2.1 ThreadPoolExecutor 线程池的七大参数
- corePoolSize：核心线程数【一直存在除非(allowCoreThreadTimeOut)】，线程池创建好后就准备就绪，等待任务。
- maximumPoolSize：最大线程数，控制资源。
- keepAliveTime：存活时间。如果当前的线程数大于核心线程数，只要线程空闲大于指定的keepAliveTime，就会释放空闲的线程【maximumPoolSize-corePoolSize】。
- unit：存活时间的时间单位。
- workQueue：阻塞队列。如果当前对线程的需求超过核心线程数，就会将多余的任务放到阻塞队列。如果有空闲的线程，就会去队列里取出新的任务继续执行。
- threadFactory：创建线程的工厂。
- handler：拒绝策略。提交给线程池的任务量超过最大线程池大小+队列长度，按照我们指定的拒绝策略拒绝执行任务。
- ThreadPoolExecutor.AbortPolicy：抛出 RejectedExecutionException来拒绝新任务的处理。
- ThreadPoolExecutor.CallerRunsPolicy：调用执行自己的线程运行任务。
- ThreadPoolExecutor.DiscardPolicy：不处理新任务，直接丢弃掉。
- ThreadPoolExecutor.DiscardOldestPolicy： 此策略将丢弃最早的未处理的任务请求。
1.2.1.2.2 运行流程
1、线程池创建，准备好core数量的核心线程，准备接受任务。
2、core 满了， 就将再进来的任务放入阻塞队列中。 空闲的 core 就会自己去阻塞队列获取任务执行。
3、阻塞队列满了， 就直接开新线程执行， 最大只能开到 max 指定的数量
4、如果线程数开到了 max 的数量， 还有新任务进来， 就会使用 RejectedExecutionHandler拒绝任务。
5、max 都执行好了。 Max-core 数量空闲的线程会在 keepAliveTime 指定的时间后自 动销毁。 最终保持到 core 大小 。
1.2.1.2.3 线程池面试题
问题：一个线程池 core 7； max 20 ， queue： 50， 100 并发进来怎么分配的；
答案：先有 7 个能直接得到执行， 接下来 50 个进入队列排队， 在多开 13 个继续执行。 现在 70 个被安排上了。 剩下 30 个默认拒绝策略。
1.2.2 常见的 4 种线程池
- newCachedThreadPool：创建一个可缓存线程池， 如果线程池长度超过处理需要， 可灵活回收空闲线程， 若无可回收， 则新建线程。
- newFixedThreadPool：创建一个定长线程池， 可控制线程最大并发数， 超出的线程会在队列中等待。
- newScheduledThreadPool：创建一个定长线程池， 支持定时及周期性任务执行。
- newSingleThreadExecutor：创建一个单线程化的线程池， 它只会用唯一的工作线程来执行任务， 保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。
1.2.3 使用线程池的好处
- 降低资源的消耗：通过重复利用已经创建好的线程降低线程的创建和销毁带来的损耗。
- 提高响应速度：因为线程池中的线程数没有超过线程池的最大上限时， 有的线程处于等待分配任务的状态， 当任务来时无需创建新的线程就能执行。
- 提高线程的可管理性：线程池会根据当前系统特点对池内的线程进行优化处理， 减少创建和销毁线程带来的系统开销。 无限的创建和销毁线程不仅消耗系统资源， 还降低系统的稳定性， 使用线程池进行统一分配。
1.3 CompletableFuture异步编排
在 Java 8 中, 新增加了一个包含 50 个方法左右的类: CompletableFuture， 提供了非常强大的Future 的扩展功能， 可以帮助我们简化异步编程的复杂性， 提供了函数式编程的能力， 可以通过回调的方式处理计算结果， 并且提供了转换和组合 CompletableFuture 的方法。CompletableFuture 类实现了 Future 接口， 所以你还是可以像以前一样通过`get`方法阻塞或者轮询的方式获得结果， 但是这种方式不推荐使用。
CompletableFuture 和 FutureTask 同属于 Future 接口的实现类， 都可以获取线程的执行结果。
1.3.1 启动异步任务
CompletableFuture 提供了四个静态方法来创建一个异步操作。
public static CompletableFuture runAsync(Runnable runnable)
public static CompletableFuture runAsync(Runnable runnable,Executor executor)
public static CompletableFuture supplyAsync(Supplier supplier)
public static CompletableFuture supplyAsync(Supplier supplier,Executor executor) 注意：
（1）runAsync都是没有返回结果的，supplyAsync都是可以获取返回结果的；
（2）可以传入自定义的线程池，否则就用默认的线程池；
（3）Async代表异步方法。
1.3.1.1 runAsync没有返回值
public static void main(String[] args) {
System.out.println("main...start...");
CompletableFuture future = CompletableFuture.runAsync(() -> {
System.out.println("当前线程：" + Thread.currentThread().getId());
int i = 10 / 2;
System.out.println("运行结果：" + i);
}, executorService);
System.out.println("main...end...");
} 测试结果：
1.3.1.2 supplyAsync有返回值
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println("main...start...");
CompletableFuture future = CompletableFuture.supplyAsync(() -> {
System.out.println("当前线程：" + Thread.currentThread().getId());
int i = 10 / 2;
System.out.println("运行结果：" + i);
return i;
}, executorService);
Integer integer = future.get();
System.out.println("main...end..."+integer);
} 测试结果：
1.3.2 完成回调与异常感知
public CompletableFuture whenComplete(BiConsumer action)
public CompletableFuture whenCompleteAsync(BiConsumer action)
public CompletableFuture whenCompleteAsync(BiConsumer action, Executor executor)
public CompletableFuture exceptionally(Function fn) whenComplete可以处理正常和异常的结果， exceptionally 处理异常情况。
whenComplete 和 whenCompleteAsync 的区别：
- whenComplete： 是执行当前任务的线程执行继续执行 whenComplete 的任务。
- whenCompleteAsync： 是执行把 whenCompleteAsync 这个任务继续提交给线程池
来进行执行。
注意：方法不以 Async 结尾， 意味着 Action 使用相同的线程执行， 而 Async 可能会使用其他线程执行（如果是使用相同的线程池， 也可能会被同一个线程选中执行）
1.3.2.1 完成回调 whenComplete
- 无异常情况
public class ThreadTest {
public static ExecutorService executorService = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println("main...start...");
//CompletableFuture future = CompletableFuture.runAsync(() -> {
// System.out.println("当前线程：" + Thread.currentThread().getId());
// int i = 10 / 2;
// System.out.println("运行结果：" + i);
//}, executorService);
CompletableFuture future = CompletableFuture.supplyAsync(() -> {
System.out.println("当前线程：" + Thread.currentThread().getId());
int i = 10 / 1;
System.out.println("运行结果：" + i);
return i;
}, executorService).whenComplete((result,exception)->{
// 可以感知到异常，但无法修改返回数据
System.out.println("异步任务完成了...返回值为："+result+";异常为："+exception);
});
//Integer integer = future.get();
System.out.println("main...end...");
}
} 
- 有异常情况
将 int i = 10/1; 改为 int i = 10/0;
1.3.2.2 异常感知 exceptionally
- 无异常情况（不会进入exceptionally）
public class ThreadTest {
public static ExecutorService executorService = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println("main...start...");
//CompletableFuture future = CompletableFuture.runAsync(() -> {
// System.out.println("当前线程：" + Thread.currentThread().getId());
// int i = 10 / 2;
// System.out.println("运行结果：" + i);
//}, executorService);
CompletableFuture future = CompletableFuture.supplyAsync(() -> {
System.out.println("当前线程：" + Thread.currentThread().getId());
int i = 10 / 2;
System.out.println("运行结果：" + i);
return i;
}, executorService).whenComplete((result,exception)->{
// 可以感知到异常，但无法修改返回数据
System.out.println("异步任务完成了...返回值为："+result+";异常为："+exception);
}).exceptionally(throwable -> {
// 可以感知异常，同时返回默认值
return 10;
});
Integer integer = future.get();
System.out.println("main...end..."+integer);
}
} - 有异常情况
将 int i = 10/2; 改为 int i = 10/0;
1.3.3 handle 最终处理
一般用handle，因为whencomplete如果异常不能给定默认返回结果，需要再调用exceptionally，而handle可以。
handle方法作用：获得前一任务的返回值【handleAsync可以是异步执行的】，也可以处理上一任务的异常，调用exceptionally修改前一任务的返回值【只有在异常情况时给一个默认返回值】而handle方法可以简化操作。
- 无异常情况
public class ThreadTest {
public static ExecutorService executorService = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println("main...start...");
//CompletableFuture future = CompletableFuture.runAsync(() -> {
// System.out.println("当前线程：" + Thread.currentThread().getId());
// int i = 10 / 2;
// System.out.println("运行结果：" + i);
//}, executorService);
/**
* 方法执行完成后的感知
*/
//CompletableFuture future = CompletableFuture.supplyAsync(() -> {
// System.out.println("当前线程：" + Thread.currentThread().getId());
// int i = 10 / 2;
// System.out.println("运行结果：" + i);
// return i;
//}, executorService).whenComplete((result,exception)->{
// // 可以感知到异常，但无法修改返回数据
// System.out.println("异步任务完成了...返回值为："+result+";异常为："+exception);
//}).exceptionally(throwable -> {
// // 可以感知异常，同时返回默认值
// return 10;
//});
/**
* 方法执行完成后的处理
*/
CompletableFuture future = CompletableFuture.supplyAsync(() -> {
System.out.println("当前线程：" + Thread.currentThread().getId());
int i = 10 / 4;
System.out.println("运行结果：" + i);
return i;
}).handle((res, thr) -> {
if (res != null) {
return res * 2;
}
if (thr != null) {
return 10;
}
return 0;
});
// R apply(T t, U u);
Integer integer = future.get();
System.out.println("main...end..."+integer);
}
} 
- 有异常情况
将 int i = 10/4; 改为 int i = 10/0;
1.3.4 线程串行化
public CompletableFuture thenApply(Function fn)
public CompletableFuture thenApplyAsync(Function fn)
public CompletableFuture thenApplyAsync(Function fn, Executor executor)
public CompletableFuture thenAccept(Consumer action)
public CompletableFuture thenAcceptAsync(Consumer action)
public CompletableFuture thenAcceptAsync(Consumer action,Executor executor)
public CompletableFuture thenRun(Runnable action)
public CompletableFuture thenRunAsync(Runnable action)
public CompletableFuture thenRunAsync(Runnable action,Executor executor) thenApply 方法： 当一个线程依赖另一个线程时， 获取上一个任务返回的结果， 并返回当前
任务的返回值。
thenAccept 方法： 消费处理结果。 接收任务的处理结果， 并消费处理， 无返回结果。
thenRun 方法： 只要上面的任务执行完成， 就开始执行 thenRun， 只是处理完任务后， 执行
thenRun 的后续操作
带有 Async 默认是异步执行的。 同之前。
以上都要前置任务成功完成。
Function
T： 上一个任务返回结果的类型。
U： 当前任务的返回值类型 。
1.3.4.1 thenRunAsync
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println("main...start...");
CompletableFuture.supplyAsync(() -> {
System.out.println("当前线程：" + Thread.currentThread().getId());
int i = 10 / 4;
System.out.println("运行结果：" + i);
return i;
}).thenRunAsync(()->{
// 不接收上一步结果，无返回值
System.out.println("任务2启动了...");
},executorService);
System.out.println("main...end...");
}执行结果：
1.3.4.2 thenAcceptAsync
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println("main...start...");
CompletableFuture.supplyAsync(() -> {
System.out.println("当前线程：" + Thread.currentThread().getId());
int i = 10 / 4;
System.out.println("运行结果：" + i);
return i;
}).thenAcceptAsync(res -> {
// thenRunAsync：不接收上一步结果，无返回值
// thenAcceptAsync：接收上一步结果，无返回值 void accept(T t);
System.out.println("任务2启动了..." + res);
}, executorService);
System.out.println("main...end...");
}执行结果：
1.3.4.3 thenApplyAsync
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println("main...start...");
CompletableFuture future = CompletableFuture.supplyAsync(() -> {
System.out.println("当前线程：" + Thread.currentThread().getId());
int i = 10 / 4;
System.out.println("运行结果：" + i);
return i;
}).thenApplyAsync(res -> {
// thenRunAsync：不接收上一步结果，无返回值
// thenAcceptAsync：接收上一步结果，无返回值 void accept(T t);
// thenApplyAsync：接收上一步结果，有返回值 R apply(T t);
System.out.println("任务2启动了..." + res);
return "Hello" + res;
}, executorService);
System.out.println("main...end..."+future.get());
} 执行结果：
1.3.5 两个任务组合 - 都要完成
public CompletableFuture thenCombine(CompletionStage other,
BiFunction fn)
public CompletableFuture thenCombineAsync(CompletionStage other,
BiFunction fn)
public CompletableFuture thenCombineAsync(CompletionStage other,
BiFunction fn, Executor executor)
public CompletableFuture thenAcceptBoth(CompletionStage other,
BiConsumer action)
public CompletableFuture thenAcceptBothAsync(CompletionStage other,
BiConsumer action)
public CompletableFuture thenAcceptBothAsync(CompletionStage other,
BiConsumer action, Executor executor)
public CompletableFuture runAfterBoth(CompletionStage other,Runnable action)
public CompletableFuture runAfterBothAsync(CompletionStage other,Runnable action)
public CompletableFuture runAfterBothAsync(CompletionStage other,Runnable action,
Executor executor) 两个任务必须都完成， 触发该任务。
thenCombine： 组合两个 future， 获取两个 future 的返回结果， 并返回当前任务的返回值
thenAcceptBoth： 组合两个 future， 获取两个 future 任务的返回结果， 然后处理任务， 没有
返回值。
runAfterBoth： 组合两个 future， 不需要获取 future 的结果， 只需两个 future 处理完任务后，
处理该任务。
1.3.5.1 runAfterBothAsync
public class ThreadTest {
public static ExecutorService executorService = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println("main...start...");
/**
* 两个任务组合-都要完成
*/
CompletableFuture future01 = CompletableFuture.supplyAsync(() -> {
System.out.println("任务1线程："+Thread.currentThread().getId());
int i = 10/4;
System.out.println("任务1结束。。。");
return i;
}, executorService);
CompletableFuture future02 = CompletableFuture.supplyAsync(() -> {
System.out.println("任务2线程："+Thread.currentThread().getId());
System.out.println("任务2结束。。。");
return "Hello";
}, executorService);
future01.runAfterBothAsync(future02,()->{
System.out.println("任务3开始");
},executorService);
System.out.println("main...end...");
}
} 执行结果：
1.3.5.2 thenAcceptBothAsync
public class ThreadTest {
public static ExecutorService executorService = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println("main...start...");
/**
* 两个任务组合-都要完成
*/
CompletableFuture future01 = CompletableFuture.supplyAsync(() -> {
System.out.println("任务1线程："+Thread.currentThread().getId());
int i = 10/4;
System.out.println("任务1结束。。。");
return i;
}, executorService);
CompletableFuture future02 = CompletableFuture.supplyAsync(() -> {
System.out.println("任务2线程："+Thread.currentThread().getId());
System.out.println("任务2结束。。。");
return "Hello";
}, executorService);
//future01.runAfterBothAsync(future02,()->{
// System.out.println("任务3开始");
//},executorService);
future01.thenAcceptBothAsync(future02,(f1,f2)->{
//void accept(T t, U u);
System.out.println("任务3开始。。。之前的结果："+f1+"->"+f2);
},executorService);
System.out.println("main...end...");
}
} 执行结果：
1.3.5.3 thenCombineAsync
public class ThreadTest {
public static ExecutorService executorService = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println("main...start...");
/**
* 两个任务组合-都要完成
*/
CompletableFuture future01 = CompletableFuture.supplyAsync(() -> {
System.out.println("任务1线程："+Thread.currentThread().getId());
int i = 10/4;
System.out.println("任务1结束。。。");
return i;
}, executorService);
CompletableFuture future02 = CompletableFuture.supplyAsync(() -> {
System.out.println("任务2线程："+Thread.currentThread().getId());
System.out.println("任务2结束。。。");
return "Hello";
}, executorService);
//future01.runAfterBothAsync(future02,()->{
// System.out.println("任务3开始");
//},executorService);
//future01.thenAcceptBothAsync(future02,(f1,f2)->{
// //void accept(T t, U u);
// System.out.println("任务3开始。。。之前的结果："+f1+"->"+f2);
//},executorService);
CompletableFuture future = future01.thenCombineAsync(future02, (f1, f2) -> {
return f1 + "->" + f2 + "->相柳"; // R apply(T t, U u);
}, executorService);
System.out.println("main...end..."+future.get());
}
} 执行结果：
1.3.6 两个任务组合 - 一个完成
public CompletableFuture applyToEither(CompletionStage other, Function fn)
public CompletableFuture applyToEitherAsync(CompletionStage other, Function fn)
public CompletableFuture applyToEitherAsync(CompletionStage other, Function fn,Executor executor)
public CompletableFuture acceptEither(CompletionStage other, Consumer action)
public CompletableFuture acceptEitherAsync(CompletionStage other, Consumer action)
public CompletableFuture acceptEitherAsync(CompletionStage other, Consumer action,Executor executor)
public CompletableFuture runAfterEither(CompletionStage other,Runnable action)
public CompletableFuture runAfterEitherAsync(CompletionStage other,Runnable action)
public CompletableFuture runAfterEitherAsync(CompletionStage other,Runnable action,Executor executor) 当两个任务中， 任意一个 future 任务完成的时候， 执行任务。
applyToEither： 两个任务有一个执行完成， 获取它的返回值， 处理任务并有新的返回值。
acceptEither： 两个任务有一个执行完成， 获取它的返回值， 处理任务， 没有新的返回值。
runAfterEither： 两个任务有一个执行完成， 不需要获取 future 的结果， 处理任务， 也没有返
回值。
1.3.6.1 runAfterEitherAsync
线程1执行完成，线程2睡了3秒，达成runAfterEitherAsync执行条件
public class ThreadTest {
public static ExecutorService executorService = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println("main...start...");
CompletableFuture future01 = CompletableFuture.supplyAsync(() -> {
System.out.println("任务1线程："+Thread.currentThread().getId());
int i = 10/4;
System.out.println("任务1结束。。。");
return i;
}, executorService);
CompletableFuture future02 = CompletableFuture.supplyAsync(() -> {
System.out.println("任务2线程："+Thread.currentThread().getId());
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("任务2结束。。。");
return "Hello";
}, executorService);
/**
* 两个任务，只要有一个完成，我们就执行任务3
*/
future01.runAfterEitherAsync(future02,()->{
System.out.println("任务3开始。。。之前的结果：");
},executorService);
System.out.println("main...end...");
}
} 执行结果：
1.3.6.2 acceptEitherAsync
两个任务的返回值类型要一致，这里全改为Object
public class ThreadTest {
public static ExecutorService executorService = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println("main...start...");
CompletableFuture执行结果：
1.3.6.3 applyToEitherAsync
public class ThreadTest {
public static ExecutorService executorService = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println("main...start...");
CompletableFuture执行结果：
1.3.7 多任务组合
public static CompletableFuture allOf(CompletableFuture... cfs)
public static CompletableFuture allOf： 等待所有任务完成
anyOf： 只要有一个任务完成
1.3.7.1 allOf
让查询商品介绍睡3秒钟，便于观察。
public class ThreadTest {
public static ExecutorService executorService = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println("main...start...");
CompletableFuture futureImg = CompletableFuture.supplyAsync(() -> {
System.out.println("查询商品的图片信息");
return "hello.jpg";
}, executorService);
CompletableFuture futureAttr = CompletableFuture.supplyAsync(() -> {
System.out.println("查询商品的属性");
return "白色+256G";
}, executorService);
CompletableFuture futureDesc = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("查询商品介绍");
return "小米";
}, executorService);
CompletableFuture allOf = CompletableFuture.allOf(futureImg, futureAttr, futureDesc);
allOf.get();// 等待所有任务完成
System.out.println("main...end..."+futureImg.get()+"->"+futureAttr.get()+">"+futureDesc.get());
}
} 执行结果：
1.3.7.2 anyOf
public class ThreadTest {
public static ExecutorService executorService = Executors.newFixedThreadPool(10);
public static void main(String[] args) throws ExecutionException, InterruptedException {
System.out.println("main...start...");
CompletableFuture futureImg = CompletableFuture.supplyAsync(() -> {
System.out.println("查询商品的图片信息");
return "hello.jpg";
}, executorService);
CompletableFuture futureAttr = CompletableFuture.supplyAsync(() -> {
System.out.println("查询商品的属性");
return "白色+256G";
}, executorService);
CompletableFuture futureDesc = CompletableFuture.supplyAsync(() -> {
try {
Thread.sleep(3000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("查询商品介绍");
return "小米";
}, executorService);
//CompletableFuture allOf = CompletableFuture.allOf(futureImg, futureAttr, futureDesc);
//allOf.get();// 等待所有任务完成
//System.out.println("main...end..."+futureImg.get()+"->"+futureAttr.get()+">"+futureDesc.get());
CompletableFuture 执行结果：
2. 商品详情
2.1 环境搭建
2.1.1 SwitchHosts增加配置
添加商品详情的域名与ip映射：172.1.11.10 item.gulimall.com
2.1.2 nginx配置
配置域名 item.gulimall.com，这里之前应该配置过，如下：
server_name gulimall.com *.gulimall.com;
# 打开nginx配置文件
vi /root/docker/nginx/conf/conf.d/gulimall.conf
2.1.3 配置网关转发
将商品详情域名(item.gulimall.com)访问转发的商品服务。
- id: gulimall_host_route
uri: lb://gulimall-product
predicates:
# 由以下的主机域名访问转发到商品服务
- Host=gulimall.com,item.gulimall.com2.1.4 商品详情页面搭建
1. 将shangpinxiangqing.html复制到gulimall-product/src/main/resources/templates，并改名为item.html；
2. 将静态资源放到nginx的/root/docker/nginx/html/static/item/路径下；
3. 将item.html页面的href和src以/static/item/开头。
4. 在gulimall-product/src/main/java/com/wen/gulimall/product/web/下编写ItemController.java；
5. 启动网关服务、商品服务、搜索服务，进行测试：
1）在搜索服务点击某个商品发现无法跳转至商品详情服务，修改搜索服务list.html，如下：
通过右键商品审查元素，发现需要修改class="da"的图片跳转路径，如下:
![]()
@Controller
public class ItemController {
@GetMapping("/{skuId}.html")
public String item(@PathVariable Long skuId){
System.out.println("准备查询："+skuId+"的详情！");
return "item";
}
}2.1.5 模型抽取
封装页面需要的详情数据模型，如下：
@Data
public class SkuItemVo {
// 获取sku的基本信息 pms_sku_info
private SkuInfoEntity info;
// 获取sku的图片信息 pms_sku_images
private List images;
// 获取spu的销售属性组合
private List saleAttr;
// 获取spu的介绍
private SpuInfoDescEntity desc;
// 获取spu的规格参数信息
private List groupAttrs;
} @ToString
@Data
public class SpuItemAttrGroupVo {
private String groupName;
private List attrs;
} // 之前代码中存在
@Data
public class Attr {
private Long attrId;
private String attrName;
private String attrValue;
}@ToString
@Data
public class SkuItemSaleAttrVo {
private Long attrId;
private String attrName;
private List attrValues;
} @Data
public class AttrValueAndWithSkuIdVo {
// 属性值
private String attrValue;
// 属性编号，属性名，属性值对应的所有skuId
private String skuIds;
}2.1.6 商品详情的业务代码
2.1.6.1 controller层
@Controller
public class ItemController {
@Resource
private SkuInfoService skuInfoService;
@GetMapping("/{skuId}.html")
public String item(@PathVariable Long skuId, Model model){
// 获取sku的基本信息 pms_sku_info
// 获取sku的图片信息 pms_sku_images
// 获取spu的销售属性组合
// 获取spu的介绍
// 获取spu的规格参数信息
SkuItemVo vo = skuInfoService.item(skuId);
model.addAttribute("item",vo);
return "item";
}
}2.1.6.2 service层
public interface SkuInfoService extends IService {
...
SkuItemVo item(Long skuId);
} @Service("skuInfoService")
public class SkuInfoServiceImpl extends ServiceImpl implements SkuInfoService {
@Resource
private SkuImagesService skuImagesService;
@Resource
private SpuInfoDescService spuInfoDescService;
@Resource
private AttrGroupService attrGroupService;
@Resource
private SkuSaleAttrValueService skuSaleAttrValueService;
...
@Override
public SkuItemVo item(Long skuId) {
SkuItemVo skuItemVo = new SkuItemVo();
// 获取sku的基本信息 pms_sku_info
SkuInfoEntity info = getById(skuId);
skuItemVo.setInfo(info);
Long spuId = info.getSpuId();
Long catalogId = info.getCatalogId();
// 获取sku的图片信息 pms_sku_images
List images = skuImagesService.getImagesBySkuId(skuId);
skuItemVo.setImages(images);
// 获取spu的销售属性组合
List saleAttrVos = skuSaleAttrValueService.getSaleAttrsBySpuId(spuId);
skuItemVo.setSaleAttr(saleAttrVos);
// 获取spu的介绍
SpuInfoDescEntity spuInfoDescEntity = spuInfoDescService.getById(spuId);
skuItemVo.setDesc(spuInfoDescEntity);
// 获取spu的规格参数信息
List attrGroupVos = attrGroupService.getAttrGroupWithAttrsBySpuId(spuId,catalogId);
skuItemVo.setGroupAttrs(attrGroupVos);
return skuItemVo;
}
} 2.1.6.3 获取sku的图片信息
public interface SkuImagesService extends IService {
...
List getImagesBySkuId(Long skuId);
} @Service("skuImagesService")
public class SkuImagesServiceImpl extends ServiceImpl implements SkuImagesService {
...
@Override
public List getImagesBySkuId(Long skuId) {
List imagesEntities = this.baseMapper.selectList(new QueryWrapper().eq("sku_id", skuId));
return imagesEntities;
}
} 2.1.6.4 获取spu的规格参数
public interface AttrGroupService extends IService {
...
List getAttrGroupWithAttrsBySpuId(Long spuId, Long catalogId);
} @Service("attrGroupService")
public class AttrGroupServiceImpl extends ServiceImpl implements AttrGroupService {
...
@Override
public List getAttrGroupWithAttrsBySpuId(Long spuId, Long catalogId) {
List vos = this.baseMapper.getAttrGroupWithAttrsBySpuId(spuId,catalogId);
return vos;
}
} @Mapper
public interface AttrGroupDao extends BaseMapper {
List getAttrGroupWithAttrsBySpuId(@Param("spuId") Long spuId, @Param("catalogId") Long catalogId);
}
2.1.6.5 获取spu的销售属性组合
public interface SkuSaleAttrValueService extends IService {
...
List getSaleAttrsBySpuId(Long spuId);
} @Service("skuSaleAttrValueService")
public class SkuSaleAttrValueServiceImpl extends ServiceImpl implements SkuSaleAttrValueService {
...
@Override
public List getSaleAttrsBySpuId(Long spuId) {
List vos = this.baseMapper.getSaleAttrsBySpuId(spuId);
return vos;
}
} @Mapper
public interface SkuSaleAttrValueDao extends BaseMapper {
List getSaleAttrsBySpuId(@Param("spuId") Long spuId);
}
2.1.7 详情页渲染【P207-P209】
![]()
![]()
![]()
<
>
-
关注
对比
-
华为 HUAWEI Mate 10 6GB+128GB 亮黑色 移动联通电信4G手机 双卡双待
预约抢购
-
190103 人预约
-
预约剩余
- 京东价
-
￥
4499.00
-
预约享资格
-
预约说明
- 增值业务
- 配送至
-
北京朝阳区管庄
-
选择新地址
-
北京
朝阳区
管庄
- 北京
- 上海
- 天津
- 重庆
- 朝阳区
- 海淀区
- 东城区
- 西城区
- 4环到5环之内
- 管庄
- 北苑
-
无货， 此商品暂时售完
-
由京东 发货，并提供售后服务
- [[${attr.attrName}]]
-
[[${vals.attrValue}]]
欲约抢购流程
-
- 1.等待预约
预约即将开始
-
- 2.预约中
2017-11-15 10:35 2017-11-15 23:59
-
- 3.等待抢购
抢购即将开始
-
- 4.抢购中
火热预约
看了又看
-
![]()
-
主体
- 品牌
- 华为(HUAWEI)
-
售后保障
厂家服务
本产品全国联保，享受三包服务，质保期为：一年保
如因质量问题或故障，凭厂商维修中心或特约维修点的质量检测证明，享受7日内退货，15日内换货，15日以上在保质期内享受免费保修等安保服务！
(注：如厂家在商品介绍中有售后保障的说明，则此商品按照厂家说明执行售后保障服务。)您可以查询本品牌在各地售后服务中心的练习方式请点击这儿查询...
京东承诺
本产品全国联保，享受三包服务，质保期为：一年保
如因质量问题或故障，凭厂商维修中心或特约维修点的质量检测证明，享受7日内退货，15日内换货，15日以上在保质期内享受免费保修等安保服务！
(注：如厂家在商品介绍中有售后保障的说明，则此商品按照厂家说明执行售后保障服务。)您可以查询本品牌在各地售后服务中心的练习方式请点击这儿查询...
正品行货
京东商城向您保证所售商品均为正品行货，京东自营商品开具机打发票或电子发票。
全国联保
凭质保证书及京东商城发票，可享受全国联保服务（奢侈品、钟表除外；奢侈品、钟表由京东联系保修，享受法定三包售后服务），与您亲临商场选购的商品享受相同的质量保证。京东商城还为您提供具有竞争力的商品价格和运费政策，请您放心购买！
注：因厂家会在没有任何提前通知的情况下更改产品包装、产地或者一些附件，本司不能确保客户收到的货物与商城图片、产地、附件说明完全一致。只能确保为原厂正货！并且保证与当时市场上同样主流新品一致。若本商城没有及时更新，请大家谅解！
权利声明:
京东上的所有商品信息、客户评价、商品咨询、网友讨论等内容，是京东重要的经营资源，未经许可，禁止非法转载使用。
注：本站商品信息均来自于合作方，其真实性、准确性和合法性由信息拥有者（合作方）负责。本站不提供任何保证，并不承担任何法律责任。
价格说明:
京东价：京东价为商品的销售价，是您最终决定是否购买商品的依据。
划线价：商品展示的划横线价格为参考价，该价格可能是品牌专柜标价、商品吊牌价或由品牌供应商提供的正品零售价（如厂商指导价、建议零售价等）或该商品在京东平台上曾经展示过的销售价；由于地区、时间的差异性和市场行情波动，品牌专柜标价、商品吊牌价等可能会与您购物时展示的不一致，该价格仅供您参考。
折扣：如无特殊说明，折扣指销售商在原价、或划线价（如品牌专柜标价、商品吊牌价、厂商指导价、厂商建议零售价）等某一价格基础上计算出的优惠比例或优惠金额；如有疑问，您可在购买前联系销售商进行咨询。
异常问题：商品促销信息以商品详情页“促销”栏中的信息为准；商品的具体售价以订单结算页价格为准；如您发现活动商品售价或促销信息有异常，建议购买前先联系销售商咨询。
-
商品评价
京公网安备 11000002000088号|
京ICP证070359号|
互联网药品信息服务资格证编号(京)-经营性-2014-0008 |
新出发京零 字第大120007号
互联网出版许可证编号新出网证(京)字150号|
出版物经营许可证|
网络文化经营许可证京网文 |
[2014]2148-348号 |
违法和不良信息举报电话 |
：4006561155
Copyright © 2004-2017 京东JD.com 版权所有|
消费者维权热线：4006067733 经营证照|
购物车还没有商品，赶紧选购吧！
联系供应商
JIMI
关注店铺
分享
2.1.8 异步编排优化
所有的操作针对于商品服务gulimall-product。
2.1.8.1 自定义线程池
2.1.8.1.1 引入依赖
spring-boot-configuration-processor作用：你自己创建的配置类生成元数据信息，这样就能在你自己的配置文件中显示出来非常的方便。【可以不加】
org.springframework.boot
spring-boot-configuration-processor
true
引入以上依赖，配置文件中会显示：
2.1.8.1.2 线程池属性配置类
gulimall-product/src/main/java/com/wen/gulimall/product/config/ThreadPoolConfigProperties.java
@Data
@Component
@ConfigurationProperties(prefix = "gulimall.thread")
public class ThreadPoolConfigProperties {
private Integer coreSize;
private Integer maxSize;
private Integer keepAliveTime;
}2.1.8.1.3 配置文件中配置
gulimall:
thread:
core-size: 20
max-size: 200
keep-alive-time: 102.1.8.1.4 自定义线程池
gulimall-product/src/main/java/com/wen/gulimall/product/config/MyThreadConfig.java
/**
* @description 线程池配置
* 注意：线程池属性类ThreadPoolConfigProperties已经使用了@Component放入容器中，
* 不需要在使用@EnableConfigurationProperties(ThreadPoolConfigProperties.class)
*/
//@EnableConfigurationProperties(ThreadPoolConfigProperties.class)
@Configuration
public class MyThreadConfig {
@Bean
public ThreadPoolExecutor threadPoolExecutor(ThreadPoolConfigProperties poolProperties){
return new ThreadPoolExecutor(poolProperties.getCoreSize(),
poolProperties.getMaxSize(),
poolProperties.getKeepAliveTime(),
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(100000),
Executors.defaultThreadFactory(),
new ThreadPoolExecutor.AbortPolicy());
}
}2.1.8.2 异步编排优化商品详情业务
2.1.8.2.1 controller层
@Controller
public class ItemController {
@Resource
private SkuInfoService skuInfoService;
@GetMapping("/{skuId}.html")
public String item(@PathVariable Long skuId, Model model){
// 获取sku的基本信息 pms_sku_info
// 获取sku的图片信息 pms_sku_images
// 获取spu的销售属性组合
// 获取spu的介绍
// 获取spu的规格参数信息
SkuItemVo vo = null;
try {
vo = skuInfoService.item(skuId);
} catch (ExecutionException e) {
e.printStackTrace();
} catch (InterruptedException e) {
e.printStackTrace();
}
model.addAttribute("item",vo);
return "item";
}
}2.1.8.2.2 service层
@Service("skuInfoService")
public class SkuInfoServiceImpl extends ServiceImpl implements SkuInfoService {
@Resource
private SkuImagesService skuImagesService;
@Resource
private SpuInfoDescService spuInfoDescService;
@Resource
private AttrGroupService attrGroupService;
@Resource
private SkuSaleAttrValueService skuSaleAttrValueService;
@Resource
private ThreadPoolExecutor threadPoolExecutor;
...
@Override
public SkuItemVo item(Long skuId) throws ExecutionException, InterruptedException {
SkuItemVo skuItemVo = new SkuItemVo();
// 1.获取sku的基本信息 pms_sku_info
CompletableFuture infoFuture = CompletableFuture.supplyAsync(() -> {
SkuInfoEntity info = getById(skuId);
skuItemVo.setInfo(info);
return info;
}, threadPoolExecutor);
CompletableFuture saleAttrFuture = infoFuture.thenAcceptAsync((res) -> {
// 3.获取spu的销售属性组合
List saleAttrVos = skuSaleAttrValueService.getSaleAttrsBySpuId(res.getSpuId());
skuItemVo.setSaleAttr(saleAttrVos);
}, threadPoolExecutor);
CompletableFuture descFuture = infoFuture.thenAcceptAsync(res -> {
// 4.获取spu的介绍
SpuInfoDescEntity spuInfoDescEntity = spuInfoDescService.getById(res.getSpuId());
skuItemVo.setDesc(spuInfoDescEntity);
}, threadPoolExecutor);
CompletableFuture baseAttrFuture = infoFuture.thenAcceptAsync(res -> {
// 5.获取spu的规格参数信息
List attrGroupVos = attrGroupService.getAttrGroupWithAttrsBySpuId(res.getSpuId(), res.getCatalogId());
skuItemVo.setGroupAttrs(attrGroupVos);
}, threadPoolExecutor);
CompletableFuture imageFuture = CompletableFuture.runAsync(() -> {
// 2.获取sku的图片信息 pms_sku_images
List images = skuImagesService.getImagesBySkuId(skuId);
skuItemVo.setImages(images);
}, threadPoolExecutor);
// 等待所有任务都完成，不用写infoFuture，因为saleAttrFuture/descFuture/baseAttrFuture他们依赖infoFuture完成的结果
CompletableFuture.anyOf(saleAttrFuture,descFuture,baseAttrFuture,imageFuture).get();
return skuItemVo;
}
}