如何在java中的多线程中spwan递归调用和for循环迭代（如果可能）？

我想知道是否有可能生成每个

循环迭代

（每个

迭代

）并最终收集结果。想想这个例子，一点都不喜欢。只是一个简单的

for循环

，但其目的是扩展它。循环的

for

的主体并不重要，我只是填充了一些代码。但基本上假设它有一些昂贵的计算，每次迭代需要几分钟才能完成。所以我想在一个单独的线程中进行每个循环计算

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));

    }

}

斐波那契回归法可能无法实现。但如果可能的话，任何其他线程间并行递归调用的例子都很好

---

附言：我有线程和可运行线程的基本知识，但我想知道，对于您的第一个要求，即将昂贵的计算转化为可调用的任务，上述方法是否可行。希望它觉得有用：

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));
    }
}

导入java.util.array；
导入java.util.concurrent.*；
公共类线程繁殖{
私有最终整数线程计数=8；
私人最终整数计算_计数=60000；
私有双精度[]arr=新双精度[计算计数]；
公共空间计算（）{
ExecutorService ExecutorService=Executors.newFixedThreadPool（线程计数）；
ExecutorCompletionService completionService=新的ExecutorCompletionService（executorService）；
对于（int i=2；i<计算\u计数；i++）{
completionService.submit（新计算（i））；
}
//从所有未来任务中获取，直到所有任务完成
对于（int i=2；i<计算\u计数；i++）{
试一试{
arr[i]=completionService.take（）.get（）；
}捕捉（中断异常e）{
e、 printStackTrace（）；//做点什么
}捕获（执行例外）{
e、 printStackTrace（）；//做点什么
}
}
}
私有静态类计算实现了可调用{
私有最终整数；
私有计算（整数）{
this.num=num；
}
@凌驾
public Double call（）引发异常{
返回Math.pow（num，500）；
}
}
公共静态void main（字符串[]args）{
Threadspawns t=新的Threadspawns（）；
长启动=System.currentTimeMillis（）；
t、 计算（）；
long end=System.currentTimeMillis（）；
System.out.println（Arrays.toString（t.arr））；
System.out.println（“所用时间”+（结束-开始））；
}
}

解决您的第一个需求，即将昂贵的计算转移到可调用的任务中。希望它觉得有用：

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));
    }
}

导入java.util.array；
导入java.util.concurrent.*；
公共类线程繁殖{
私有最终整数线程计数=8；
私人最终整数计算_计数=60000；
私有双精度[]arr=新双精度[计算计数]；
公共空间计算（）{
ExecutorService ExecutorService=Executors.newFixedThreadPool（线程计数）；
ExecutorCompletionService completionService=新的ExecutorCompletionService（executorService）；
对于（int i=2；i<计算\u计数；i++）{
completionService.submit（新计算（i））；
}
//从所有未来任务中获取，直到所有任务完成
对于（int i=2；i<计算\u计数；i++）{
试一试{
arr[i]=completionService.take（）.get（）；
}捕捉（中断异常e）{
e、 printStackTrace（）；//做点什么
}捕获（执行例外）{
e、 printStackTrace（）；//做点什么
}
}
}
私有静态类计算实现了可调用{
私有最终整数；
私有计算（整数）{
this.num=num；
}
@凌驾
public Double call（）引发异常{
返回Math.pow（num，500）；
}
}
公共静态void main（字符串[]args）{
Threadspawns t=新的Threadspawns（）；
长启动=System.currentTimeMillis（）；
t、 计算（）；
long end=System.currentTimeMillis（）；
System.out.println（Arrays.toString（t.arr））；
System.out.println（“所用时间”+（结束-开始））；
}
}

我不认为递归调用可以派生到不同的线程。这是可以做到的，但这不是一个好主意，因为你需要很多线程，如果你只调用方法，线程限制远远低于递归限制。@zapl：知道这是可以做到的，这很有趣。你能详细说明一下怎么做吗。虽然这是一个坏主意，但学习是好的。您可以递归地生成线程，尽管zapl指出这是一个坏主意。一个更健壮的解决方案是具有工作线程池的可运行队列，可能的dup我不认为递归调用可以派生到不同的线程。这是可以做到的，但这是一个坏主意，因为你需要很多线程，如果你只调用方法，线程限制远低于递归限制。@zapl:知道它可以做到很有意思。你能详细说明一下怎么做吗。虽然这是一个坏主意，但学习是好的。您可以递归地生成线程，尽管zapl指出这是一个坏主意。一个更健壮的解决方案是具有工作线程池（可能是dup）的可运行队列