マルチスレッドを作成する4つの方法（スレッドプールフォーカス）

1.統合スレッド

2.Rubbableインターフェースを実装します

3.FuturTaskを使用してCallableインターフェースを実装します

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.スレッドプール

リソースを制御できないため、スレッドプールの3つの一般的に使用される方法（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();
        }

ここでスレッドプールの7つの重要なパラメーター注：ここでソースコードを見ると、5つのパラメーターしか見つかりません。

この

パラメーターを最大2 Integer.MAX_VALUE 2147483647と呼ぶには、7つのパラメーターが内部を通過することを確認する必要があります。
パラメータを説明する34。たとえば、この方法では、多数のリクエストが着信すると、複数のスレッドを作成し、後で特定の時間単位にそれほど多くのリクエストがない場合は、特定の時間単位で使用されていないスレッドを閉じます。一定期間（たとえば、忙しすぎて残業するために呼び出されない場合、その後、私は忙しくなく、早く仕事を辞めました）。
//创建一个会自动扩容的线程池 ExecutorService executorService3 = Executors.newCachedThreadPool();
パラメータ7。つまり、スレッドの最大数とブロッキングキューがすべていっぱいになり、拒否戦略がアクティブになります。

ここに画像の説明を挿入

4つの拒否戦略

ここに画像の説明を挿入

手書き変換スレッドプール

数が2で最大が5のコアスレッド、ブロッキングキューが3、タイムアウトが1のコアスレッドを作成して、新しいスレッドのスレッドプールブロッキング戦略を破棄します。

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

スレッドプールを合理的に構成する方法

まず、コンピューター上のコアの数を確認しますSystem.out.println（Runtime.getRuntime（）。availableProcessors（））;
コアの数+ 1 =スレッドの最大数

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を実行します。

future01.thenAcceptBothAsync（）これは前の結果を受け取る
ことができますfuture01.thenCombineAsync（）これは戻り値を定義できます

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<>(100000),
                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;
    }