我正在使用Java 21和Sping Boot 3.2.0（SNAPSHOT）。我有更多的类，但我只显示这种情况下的基本类。我试图使用ExecutorService在多线程环境中检查一些记录，并根据检查结果继续或停止ExecutorService。
SecurityCheckc类：

private ExecutorService pool;
    private final SendToDatabse sendToDatabse;
    private final UserCheck userCheck;
    private final SynchronisedCheckedMap synchronisedCheckedMap;

    public SecurityCheck(SendToDatabse sendToDatabse,
                         UserCheck userCheck,
                         SynchronisedCheckedMap synchronisedCheckedMap) {
        this.sendToDatabse = sendToDatabse;
        this.userCheck = userCheck;
        this.synchronisedCheckedMap = synchronisedCheckedMap;

    }

    public void securityCheck(List<String> list) throws ExecutionException, InterruptedException, TimeoutException {
        List<Future<?>> futures = new ArrayList<>();
        this.pool = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
        try {
            list.forEach(line -> futures.add(pool.submit(
                    new Security(line,
                                this.userCheck,
                                this.synchronisedCheckedMap
                            ))));

            for (Future<?> future : futures) {
                future.get(Long.MAX_VALUE, TimeUnit.SECONDS);
            }
        }catch (Exception e){
            throw new RuntimeException(e);
        }
        finally {
            print();
            pool.shutdown();
            while (!pool.awaitTermination(24L,TimeUnit.SECONDS)){
                System.out.println("Not yet. Still in waiting for termination");
            }
//            this.sendToDatabse.sendToDatabse(synchronisedCheckedMap.synchronisedCheckedMap);
        }
    }

    public void stopPool(Short code, Customer customer){

        System.out.println("oprire");
        Map<Short, List<Customer>> map = new HashMap<>();
        map.put(code, (List<Customer>) customer);
        map.forEach((k,v)->{
            System.out.println(k + "\t" + v);
        });
        this.pool.shutdownNow();
//        this.sendToDatabse.sendToDatabse(map);

        Thread.currentThread().interrupt();
    }

字符串
安全类：

public class Security implements SQLInjections, Runnable{
    private final String line;
    private final UserCheck userCheck;
    private final SynchronisedCheckedMap synchronisedCheckedMap;
    public Security(String line,
                    UserCheck userCheck,
                    SynchronisedCheckedMap synchronisedCheckedMap){
        this.line = line;
        this.userCheck = userCheck;
        this.synchronisedCheckedMap = synchronisedCheckedMap;
    }

    @Override
    public void run() {
        try {
            if (Thread.interrupted()) {
                return;
            }

            JsonToLine jsonToLine = new JsonToLine();
            String newLine = jsonToLine.jsonToLine(line);

            StringToValues stringToValues = new StringToValues();
            List<String> values = stringToValues.stringToValues(newLine);
//        values.forEach(string -> {System.out.println("line: " + string);});
            Short validID = validID(values.get(0));
            Short validUser = null;
            Short validPassword = null;
            Short validMessage = null;
            List<String> message = new ArrayList<>();
            Customer customer;

            switch (validID) {
                case 200:
//                    values.forEach(string -> {System.out.println("code" + "\t" + "line: " + string);});
                    validUser = validUser(values.get(1));
                    validPassword = validPassword(values.get(2));
                    message = Arrays.asList(values.get(3).split(";"));
                    validMessage = validMesage(message);
                    customer =
                            new Customer(Long.parseLong(values.get(0)),
                                    values.get(1),
                                    values.get(2),
                                    message);

                    if(validUser==200 &&
                        validMessage==200 &&
                        validPassword==200){

                        this.synchronisedCheckedMap.synchronisedCheckedMap((short) 200, customer);

                    }else{

                        this.synchronisedCheckedMap.synchronisedCheckedMap(
                                getHighestCode(List.of(validUser,validID,validMessage,validPassword)), customer);
                    }

                    break;

                case 600:

                    validUser = validUser(values.get(0));
                    validPassword = validPassword(values.get(1));
                    message = Arrays.asList(values.get(3).split(";"));
                    validMessage = validMesage(message);
                    customer =
                            new Customer(null,
                                    values.get(1),
                                    values.get(2),
                                    message);

                    this.synchronisedCheckedMap.synchronisedCheckedMap((short) 600, customer);
                    break;
            }

        }catch (Exception e){
            Thread.currentThread().interrupt(); // Preserve interruption status
            return;
        }

    }
}

型
我还有SyncroniseMap

@Component
public class SynchronisedCheckedMap {

    public Map<Short, List<Customer>> synchronisedCheckedMap = new HashMap<>();
    private  SecurityCheck securityCheck;

    public SynchronisedCheckedMap(SecurityCheck securityCheck) {
        this.securityCheck = securityCheck;
    }

    public SynchronisedCheckedMap() {}

    protected synchronized void synchronisedCheckedMap(Short code,
                                                       Customer customer){

        if(code>=800){
            this.securityCheck.stopPool(code,customer);
        }

        if(this.synchronisedCheckedMap.containsKey(code)){
            this.synchronisedCheckedMap.get(code).add(customer);
        }else {
            List<Customer> list = new ArrayList<>();
            list.add(customer);
            synchronisedCheckedMap.put(code,list);
        }
    }

    public void print(){
        this.synchronisedCheckedMap.forEach((k,v)->{
            System.out.println(k + "\t" + v);
        });
    }

}

型
我把这个类中的依赖注入搞砸了，因为它根本不工作。线程仍然在运行。但是我试图在“stopPool”方法上放置调试器，并且没有停止。
我知道我将不得不在这些方面做更多的工作，但我想从SecurityCheck类中停止ExecutorService。当它是一个发送到“this. synchronisedBikedMap. synchronisedBikedMap”的特定代码时，我试图调用“stopPool”方法。
我已经尝试过这样做，但我需要帮助才能使它工作，因为线程继续下去。
在这种情况下，我应该如何正确地停止ExecutorService？