使用fork/join实现Java并行化组合

我试图将一个组合优化问题并行化。基本上，我想检查每个大小k的组合（n选择k），看看组合是否是最好的。我编写了一个可以正常工作的顺序版本（以下是java代码）：

public int-bestCombo（int[]al，int[]data，int-start，int-end，int-index，int-k）{
如果（索引==k）{
//你有独特的组合
返回CalculateBestComposition（数据）；
}否则{
int-best=0；
for（int i=start；i=k-index；i++）{
数据[指数]=al[i]；
int temp=最佳组合（al，数据，i+1，end，索引+1，k）；
如果（最佳<温度）{
最佳=温度
}
}
回报最好；
}
}

因此，我的代码在递归树的叶子上进行计算，在叶子上，我将有一个大小k的唯一组合，非常简单。现在我将其转换为fork/join代码，但没有得到正确的解决方案。以下是我在java代码中的fork/join代码：

public int bestCombo(int[] al, int[] data, int start, int end, int index, int k) {
    if (index == k) {
        // you have unique combination
        return calculateBestCombination(data);
    } else {
        int best = 0;
        for (int i = start; i <= end && end-i+1 >= k-index; i ++){
            data[index] = al[i];
            int temp = bestCombo(al, data, i+1, end, index+1, k);
            if (best < temp) {
              best = temp
            }
        }
        return best;
    }
}

public class ParallelizeCombo extends RecursiveTask<MintSolution> {
    private int[] array;
    private int[] data;
    private int start;
    private int end;
    private int index;
    private int k;

    public ParallelizeCombo(int[] arr, int[] data, int start, int end, int index, int k) {
        super();
        this.array = arr;
        this.data = data;
        this.start = start;
        this.end = end;
        this.index = index;
        this.k = k;
    }

    @Override
    protected int compute() {
        // base case, we have reached the end of the combo
        if (this.index == k) {
            return calculateBestCombination(this.data);
        } else {
            List<ParallelizeCombo> subtasks = new ArrayList();
            for (int i = this.start; i <= this.end && this.end-i + 1 >= this.r-this.index; i ++) {
                this.data[this.index] = this.array[i];
                ParallelizeCombo pc = new ParallelizeCombo(this.array, this.data, i+1, this.end, this.index+1, this.k);
                subtasks.add(pc);
            }
            // run subtasks
            for (ParallelizeCombo subtask: subtasks) {
                subtask.fork();
            }
            int best = 0;
            // join the subtasks
            for (ParallelizeCombo subtask: subtasks) {
                int temp = subtask.join();
                if (best < int) {
                    best = int
                }
            }
            return best;
        }
    }
}

public类parallelizembo扩展递归任务{
私有int[]数组；
私有int[]数据；
私人int启动；
私人互联网终端；
私有整数索引；
私人INTK；
public parallelizembo（int[]arr，int[]data，int start，int end，int index，int k）{
超级（）；
this.array=arr；
这个数据=数据；
this.start=start；
this.end=end；
这个指数=指数；
这个。k=k；
}
@凌驾
受保护的int compute（）{
//基本情况下，我们已经到达组合的末尾
if（this.index==k）{
返回calculateBestCombination（此.data）；
}否则{
列表子任务=新建ArrayList（）；
for（int i=this.start；i=this.r-this.index；i++）{
this.data[this.index]=this.array[i]；
ParallelizeCombo pc=新的ParallelizeCombo（this.array，this.data，i+1，this.end，this.index+1，this.k）；
子任务。添加（pc）；
}
//运行子任务
for（parallelizembo子任务：子任务）{
子任务fork（）；
}
int-best=0；
//加入子任务
for（parallelizembo子任务：子任务）{
int temp=subtask.join（）；
如果（最佳

---

我很困惑，因为代码基本相同。唯一的区别是，在fork/join中的for循环中，我在多线程中运行它。然而，我得到的解决方案是完全不同的，fork/join解决方案是非常错误的。有人知道为什么吗？

好吧，我知道了。我是个白痴。。。问题如下：

public ParallelizeCombo(int[] arr, int[] data, int start, int end, int index, int k) {
    super();
    this.array = arr;
    this.data = data;
    this.start = start;
    this.end = end;
    this.index = index;
    this.k = k;
}

---

这里，this.data不是创建新数据，而是仅仅指向数据（通过引用）。因此，当您在特定时间对数据计算bestcomposition时，它可能不是您认为的组合（其他线程可能已经更改了数据的值）。

如果您在不同的线程中对数组进行变异，那么您会遇到一个大问题。对于单纯形算法来说，这似乎是一项非常简单的任务——为什么不简单地使用优化库呢？