如何在Java中的多個線程中生成遞歸調用並進行循環迭代（如果可能）？

Question

我想知道是否有可能生成每個loop iteration （每個iteration本身都生成一個thread ）並最終收集結果。 考慮一下這個例子，一點兒也不花哨。 只是一個簡單的for-loop ，但其思想是對其進行擴展。 for loop的主體無關緊要，我只填寫了一些代碼。 但基本上假設它有一些昂貴的計算，每次迭代都需要幾分鍾才能完成。 所以我想在一個單獨的線程中進行每個循環計算。

public class Threadspawns {

    private double[] arr = new double[4];

    public void calculations(){
        for (int i =2; i < 6; i++){
                   //expensive calculation
            arr[i-2]=Math.pow(i,500);
        }
    }

    public static void main(String[] args){
        Threadspawns t = new Threadspawns();
        long start = System.currentTimeMillis();
        t.calculations();
        long end = System.currentTimeMillis();
        System.out.println(Arrays.toString(t.arr));
        System.out.println("time taken "+ (end-start));

    }

}

同樣，如果有可能將recursive calls實際拆分為多個線程，並在返回時收集它們。 例子是斐波那契

public static int fibonacci(int n){
        if (n==0)
            return 0;
        if (n==1)
            return 1;
        return fibonacci(n-2)+fibonacci(n-1);
    }

斐波那契遞歸方法可能無法做到這一點。 但是如果可能的話，可以在線程之間並行並行執行遞歸調用的任何其他示例。

PS：我具有Thread and Runnable基本知識，但想知道上面的方法是否可行

Answer 1

解決您的第一個要求的解決方案，即將昂貴的計算轉移到可調用任務中。 希望它有用：

import java.util.Arrays;
import java.util.concurrent.*;

public class Threadspawns {
    private final int THREAD_COUNT = 8;
    private final int CALCULATION_COUNT = 60000;
    private double[] arr = new double[CALCULATION_COUNT];

    public void calculations() {
        ExecutorService executorService = Executors.newFixedThreadPool(THREAD_COUNT);
        ExecutorCompletionService<Double> completionService = new ExecutorCompletionService<Double>(executorService);
        for (int i = 2; i < CALCULATION_COUNT; i++) {
            completionService.submit(new Calculation(i));
        }

        //Get from all Future tasks till all tasks completed
        for (int i = 2; i < CALCULATION_COUNT; i++) {
            try {
                arr[i] = completionService.take().get();
            } catch (InterruptedException e) {
                e.printStackTrace();  //do something
            } catch (ExecutionException e) {
                e.printStackTrace();  //do something
            }
        }
    }

    private static class Calculation implements Callable<Double> {
        private final int num;

        private Calculation(int num) {
            this.num = num;
        }

        @Override
        public Double call() throws Exception {
            return Math.pow(num, 500);
        }
    }

    public static void main(String[] args) {
        Threadspawns t = new Threadspawns();
        long start = System.currentTimeMillis();
        t.calculations();
        long end = System.currentTimeMillis();
        System.out.println(Arrays.toString(t.arr));
        System.out.println("time taken " + (end - start));
    }
}