java为什么带ExecutorService和不带ExecutorService的任务需要相同的时间？

Question

我在spring boot中使用JDBC模板和executor服务实现了以下项目结构。应用程序使用线程和不使用线程所需的时间几乎相同。我预计时间减少至少三分之一

我从这个link中读到了以下内容，但我不知道如何在代码中应用：

为了能够在线程中使用事务，我们需要了解事务如何与spring一起工作。spring中的事务信息存储在ThreadLocal变量中。因此，这些变量特定于单个线程上正在进行的事务

是我在^{中长期运行的任务导致了问题吗

有人知道为什么吗？任何解决方案都是受欢迎的

@SpringBootApplication
public class ApplicationMain implements CommandLineRunner {
    @Autowired
    @Qualifier(value = "mainExecutorService")
    public ExecutorService mainExecutorService;

    @Autowired
    @Qualifier(value = "mut")
    public Mut mut;

    @Autowired
    @Qualifier(value = "apt")
    public Apt apt;

    public static void main(String[] args){
        SpringApplication.run(ApplicationMain.class, args);
    }

    @Override
    public void run(String... args) throws Exception {
        try {
            // First thread
            mainExecutorService.submit(() -> {
                mut.initialise("2019", "10", "31");
                apt.sum();
            }, true);

            // Second thread
            mainExecutorService.submit(() -> {
                apt.initialise("2019", "10", "31");
                mut.sum();
            }, true);
            mainExecutorService.shutdown();

            if (mainExecutorService.awaitTermination(Long.MAX_VALUE, TimeUnit.MINUTES))
                System.out.println("done");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            mainExecutorService.shutdownNow();
        }
    }
}

配置

@Configuration
class ExecutorservicConfig {
    @Bean("mainExecutorService")
    public ExecutorService mainExecutorService() {
        return Executors.newFixedThreadPool(2);
    }

    @Bean(name = "apt")
    public Apt createApt(){
        return new Apt();
    }

    @Bean(name = "mut")
    public Mut createMut(){
        return new Mut();
    }
}

界面

    interface Som {
    ExecutorService service = Executors.newCachedThreadPool();
    void initialize (String year, String month, String day);
    void sum();
    void deleteInsertUpdate();
    void execute();
    void print();
}

第一类考虑在第一个线程中执行

    class Mut implements Som {
    private String year, month, day ;

    @Autowired
    @Qualifier(value = "jdbcTemplate")
    private JdbcTemplate jdbcTemplate;
    private long staringProcessingTime;

    @Override
    public void initialize (String year, String month, String day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    @Override
    public void sum() {
        staringProcessingTime = System.currentTimeMillis();
        System.out.println("Started first thread. starting time is:".concat(String.valueOf(staringProcessingTime)));
        deleteInsertUpdate();
    }

    @Override
    public void deleteInsertUpdate() {
        String queryDelete = "";
        String queryInsert = "";
        String queryUpdate = "";

        try {
            service.submit(() -> jdbcTemplate.update(queryDelete));
            service.submit(() -> jdbcTemplate.update(queryInsert));
            service.submit(() -> jdbcTemplate.update(queryUpdate));
            service.shutdown();
            if (service.awaitTermination(Long.MAX_VALUE, TimeUnit.MINUTES))
                execute();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            service.shutdownNow();
        }
    }

    @Override
    public void execute() {
        // long running task here ....
        if( SqlUtilities.executeSql(sqlName, values, dataSource) )
            print();
    }

    @Override
    public void print() {
        long endProcessingTime = System.currentTimeMillis();
        System.out.println("Ended first thread. total time in millisecond:".concat(String.valueOf(endProcessingTime - staringProcessingTime)));
    }

}

第二个类考虑在第二个线程中执行

class Apt implements Som {
    private String year, month, day ;
    private long staringProcessingTime;

    @Autowired
    @Qualifier(value = "jdbcTemplate")
    private JdbcTemplate jdbcTemplate;

    @Override
    public void initialize (String year, String month, String day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    @Override
    public void sum() {
        staringProcessingTime = System.currentTimeMillis();
        System.out.println("Started Second thread. starting time is:".concat(String.valueOf(staringProcessingTime)));
        deleteInsertUpdate();
    }

    @Override
    public void deleteInsertUpdate() {
        String queryDelete = "";
        String queryInsert = "";
        String queryUpdate = "";

        try {
            service.submit(() -> jdbcTemplate.update(queryDelete));
            service.submit(() -> jdbcTemplate.update(queryInsert));
            service.submit(() -> jdbcTemplate.update(queryUpdate));
            service.shutdown();
            if (service.awaitTermination(Long.MAX_VALUE, TimeUnit.MINUTES))
                execute();

        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            service.shutdownNow();
        }
    }

    @Override
    public void execute() {
        // long running task here ....
        if( SqlUtilities.executeSql(sqlName, values, dataSource) )
            print();
    }

    @Override
    public void print() {
        long endProcessingTime = System.currentTimeMillis();
        System.out.println("Ended second thread. total time in millisecond:".concat(String.valueOf(endProcessingTime - staringProcessingTime)));
    }

}

实用程序类

class SqlUtilities {

public static boolean executeSql(String sqlName, Map<String,String> values, DataSource dataSource){
    ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
    boolean executed = false;
    try{
        Resource[] resources = resolver.getResources("classpath*:sql/*.sql");

        for(Resource resource: resources)
        {
            if(sqlName.equals(resource.getFilename()))
            {
                File tempFile = File.createTempFile(resource.getFilename(), ".sql");
                Path tempPath = Paths.get(tempFile.getAbsolutePath());
                try (InputStream inputStream = resource.getInputStream()) {
                    FileUtils.copyInputStreamToFile(inputStream, tempFile);

                    String contents = new String(Files.readAllBytes(tempPath));
                    String newContents = StringSubstitutor.replace(contents, values);

                    Files.write(tempPath, Collections.singleton(newContents), StandardOpenOption.TRUNCATE_EXISTING);

                    Resource tempResource = new FileUrlResource(tempPath.toString());
                    ResourceDatabasePopulator databasePopulator = new ResourceDatabasePopulator(tempResource);
                    databasePopulator.execute(dataSource);
                } finally {
                    executed = Files.deleteIfExists(tempPath);
                }
            }
        }
    }catch (Exception e){
        System.out.println(e.getMessage());;
    }

    return executed;
}