1.集成Thread

2.实现Rubbable接口

3.实现Callable接口 配合FuturTask

class myThread implements Callable<Integer>{ @Override public Integer call() throws Exception { System.out.println("come in"); return 1024; } } public class CallableDemo { public static void main(String[] args) throws ExecutionException, InterruptedException { FutureTask<Integer> futureTask = new FutureTask(new myThread()); new Thread(futureTask, "AA").start(); Integer o = futureTask.get(); System.out.println(o); } } 

4.线程池

1. 线程池三个常用的方式 (JDK自带的 实际开发我们不用) 因为不能控制资源假设高并发同时创建了很多的线程 服务器直接瘫痪…

讯享网//创建一个固定线程的线程池 ExecutorService executorService = Executors.newFixedThreadPool(3); //创建一个单个线程的线程池 ExecutorService executorService2 = Executors.newSingleThreadExecutor(); //创建一个会自动扩容的线程池 ExecutorService executorService3 = Executors.newCachedThreadPool(); try { 
    for (int i = 0; i < 10; i++) { 
    executorService3.execute(() -> { 
    System.out.println(Thread.currentThread().getName() + "*"); }); } } catch (Exception e) { 
    e.printStackTrace(); } finally { 
    executorService3.shutdown(); } 

2. 线程池的七个重要参数
   这里注意: 我们看源码的时候会发现只有五个参数 这里我为什么会说是七个参数呢
   
   讯享网
   点进去看 调用this传了七个参数
   
   
   参数2 最大值为 Integer.MAX_VALUE
   解释参数3 4。 比如说这个方法，当大量请求进来了他就会创建好多个线程，而后面一定时间单位没有那么多请求了，他就会关闭达到一定时间没有用过的线程(比如太忙被叫过来加班，后来不忙了提前下班了。)。
   //创建一个会自动扩容的线程池 ExecutorService executorService3 = Executors.newCachedThreadPool();
   参数7. 就是我们最大线程数和我们阻塞队列全部满了，将会启动拒绝策略。

四种拒绝策略

手写改造线程池

创建一个核心线程数为2 最大为5 阻塞队列为3 超时1s销毁新增线程的线程池 阻塞策略抛异常

ExecutorService pool = new ThreadPoolExecutor( 2, 5, 1L, TimeUnit.SECONDS, new LinkedBlockingDeque<>(3), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy()); 

怎么合理配置线程池

completableFuture 异步编排

这6步骤的执行有依赖关系 我们后边几步需要前面的执行结果 可以用异步编排实现

讯享网 CompletableFuture.supplyAsync(() -> { System.out.println("当前线程" + Thread.currentThread().getName()); int i = 10 / 4; System.out.println("运行结果" + i); return i; }, executorService); 

 CompletableFuture.supplyAsync(() -> { 
    System.out.println("当前线程" + Thread.currentThread().getName()); int i = 10 / 4; System.out.println("运行结果" + i); return i; }, executorService).thenRunAsync(()->{ 
    System.out.println("任务2启动了 ... 结束"); },executorService); 

任务1和任务2都执行完了 再执行任务3

讯享网CompletableFuture<Integer> future01 = CompletableFuture.supplyAsync(() -> { 
    System.out.println("任务1线程启动了..." + Thread.currentThread().getName()); int i = 10 / 4; System.out.println("运行结果" + i); System.out.println("任务1线程结束了..." + Thread.currentThread().getName()); return i; }, executorService); CompletableFuture<String> future02 = CompletableFuture.supplyAsync(() -> { 
    System.out.println("任务2线程启动了..." + Thread.currentThread().getName()); System.out.println("任务2线程结束了..." + Thread.currentThread().getName()); return "hello"; }, executorService); future01.thenAcceptBothAsync(future02,(f1,f2)->{ 
    System.out.println("任务3开始..."); System.out.println("之前的结果" + f1 + f2); },executorService); 

A和B只要有一个执行完成就执行C

多任务组合

配置并使用线程池

package com.gulimall.product.config; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import java.util.concurrent.Executors; import java.util.concurrent.LinkedBlockingDeque; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; @Configuration public class MyThreadPoolConfig { 
    @Bean public ThreadPoolExecutor threadPoolExecutor(ThreadPoolConfigProperties threadPoolConfigProperties) { 
    //配置类代码 return new ThreadPoolExecutor( threadPoolConfigProperties.getCoreSize(), threadPoolConfigProperties.getMaxSize(), threadPoolConfigProperties.getKeepActiveTime(), TimeUnit.SECONDS, new LinkedBlockingDeque<>(), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy() ); } } 

为了方便配置 我们可以自定义配置文件 并且添加下面依赖在配置文件里会有提示

讯享网<!--属性的提示工具--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-configuration-processor</artifactId> <optional>true</optional> </dependency> 

package com.gulimall.product.config; import lombok.Data; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.stereotype.Component; @ConfigurationProperties(prefix = "gulimall.thread") @Component @Data public class ThreadPoolConfigProperties { 
    private Integer coreSize; private Integer maxSize; private Integer keepActiveTime; } 

讯享网@Override public SkuItemVo item(Long skuId) throws ExecutionException, InterruptedException { 
    SkuItemVo skuItemVo = new SkuItemVo(); //异步编排 CompletableFuture<SkuInfoEntity> infoFuture = CompletableFuture.supplyAsync(() -> { //1 sku基本信息 pms_sku_info SkuInfoEntity info = getById(skuId); skuItemVo.setInfo(info); return info; }, executor); CompletableFuture<Void> imageFuture = infoFuture.thenAcceptAsync((res) -> { //2 sku图片信息 List<SkuImagesEntity> skuImagesEntities = skuImagesService.getImagesBySkuId(skuId); skuItemVo.setImages(skuImagesEntities); }, executor); CompletableFuture<Void> attrFuture = infoFuture.thenAcceptAsync((res) -> { //3 获取spu销售属性组合 List<ItemSaleAttrVo> saleAttrVos = skuSaleAttrValueService.getSaleAttrsBySpuId(res.getSpuId()); skuItemVo.setSaleAttr(saleAttrVos); }, executor); CompletableFuture<Void> descFuture = infoFuture.thenAcceptAsync((res) -> { //4 获取spu介绍 pms_spu_info_desc SpuInfoDescEntity spuInfoDescEntity = spuInfoDescService.getById(res.getSpuId()); skuItemVo.setDesc(spuInfoDescEntity); }, executor); CompletableFuture<Void> groupAttrFuture = infoFuture.thenAcceptAsync((res) -> { //5 获取spu规格参数信息 List<SpuItemAttrGroupVo> attrGroupVos = attrGroupService.getAttrGroupWithAttrsBySpuId(res.getSpuId(), res.getCatalogId()); skuItemVo.setGroupAttrs(attrGroupVos); }, executor); //等待所有的异步任务都完成才返回我们的结果 CompletableFuture.allOf(imageFuture,attrFuture,descFuture,groupAttrFuture).get(); // 6.查询当前sku是否参与秒杀优惠 return skuItemVo; }