使用Java线程进行并行编程

这是以顺序方式发生的，并造成了执行延迟，这可以转换为使用Java线程的并行执行吗？

是的，可以通过这种方式提高性能.

可能的解决方案为Java Thread:

import java.util.List;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Main {

    public static void main(String[] args) {
        List<Estimates> estimateList = ... // Set the list of Estimates objects here

        int numThreads = 3; // set the number of threads you want to use
        ExecutorService executorService = Executors.newFixedThreadPool(numThreads);

        try {
            int chunkSize = estimateList.size() / numThreads;

            for (int i = 0; i < numThreads; i++) {
                int startIndex = i * chunkSize;
                int endIndex = (i == numThreads - 1) ? estimateList.size() : (startIndex + chunkSize);
                List<Estimates> chunk = estimateList.subList(startIndex, endIndex);

                executorService.execute(() -> {
                    for (Estimates estimate : chunk) {
                        Account account = performCalculations(estimate);
                        estimate.setAccount(account);
                    }
                });
            }
        } finally {
            executorService.shutdown();
            try {
                executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
            } catch (InterruptedException e) {
                // Put the handling of a thread interruption here
            }
        }
    }

    private static Account performCalculations(Estimates estimate) {
        // do your calculations and return the Account object here
        return new Account();
    }
}

此外，我还建议采取其他 Select .

你可以用java Stream API.

       List<Estimates> updatedEstimates = estimateList.parallelStream()
            .map(estimate -> {
                Account account = performCalculations(estimate);
                estimate.setAccount(account);
                return estimate;
            })
            .collect(Collectors.toList());