我有一百万个整数的数组，因为我正在尝试并行快速排序。我有时会有以下奇怪的行为：
为了检查数组是否正确排序，我在排序后输入了以下代码：
for(int j=0; j < array_parallel.length-1; ++j)
if(array_parallel[j] > array_parallel[j+1])
System.out.println("ERROR! NOT SORTED CORRECTLY!");
在某些情况下，我得到错误输出，它没有正确排序，当我调试时，我发现以下内容（示例，总是不同）：
j=1942 array_parallel[1942] = 6000; array_parallel[1943] = 6000;
（尝试忽略数字，它不是任何特定的值或范围）所以它总是在左值等于右值的情况下。好吧，为了比较更大，这应该返回 false，但我肯定会得到输出。
到底怎么了！？
我什至交叉检查了数组，它的排序正确。如果我绘制一个小数组（大约 100 个）也可以。我错过了什么我的想法欺骗了我吗？
21:32 (UTC+1) 编辑：
private static int ANZAHL = 1000000; // Größe des Arrays
public static void main(String[] args) {
// TODO Auto-generated method stub
int array_single[] = new int[ANZAHL];
int array_parallel[] = new int[ANZAHL];
Speedmeasure sp_single = new Speedmeasure();
Speedmeasure sp_parallel = new Speedmeasure();
ArrayReader ar = null;
try {
ar = new ArrayReader(array_single, array_parallel);
} catch (FileNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
} catch (ClassNotFoundException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
if(ar == null) {
System.err.println("Großes Problem. Lass es sein!");
System.exit(-1);
}
else {
for(int i=0; i < 5; ++i) {
Quicksort_Single qs = new Quicksort_Single();
sp_single.setStart(System.currentTimeMillis());
qs.quicksort_start(array_single);
sp_single.setStop(System.currentTimeMillis());
//printArray(array);
PrintSpeed(sp_single.getSpeed(), "Single");
System.out.print("\nUnd jetzt treiben wir es parallel! \n\n");
Thread t1 = new Thread(new Quicksort_Parallel(0, array_parallel.length-1, array_parallel));
sp_parallel.setStart(System.currentTimeMillis());
t1.start();
try {
t1.join();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
sp_parallel.setStop(System.currentTimeMillis());
//printArray(array_parallel);
PrintSpeed(sp_parallel.getSpeed(),"Parallel");
System.out.println("Speed up was: "+sp_parallel.calcSpeedup(sp_single.getSpeed(), sp_parallel.getSpeed()));
System.out.println("******************************************");
for(int j=0; j < array_single.length-1; ++j)
if(array_single[j] > array_single[j+1])
System.out.println("ERROR! NICHT SORTIERT KORREKT BEI SINGLE!");
for(int j=0; j < array_parallel.length-1; ++j)
if(array_parallel[j] > array_parallel[j+1])
System.out.println("ERROR! NICHT SORTIERT KORREKT BEI PARALLEL!");
ar.copyArray(array_single, array_parallel);
}
}
}
我在启动并行排序的线程上进行连接。第一个线程最多同时产生最多 4 个线程。我不能 100% 确定它可能是什么并发，正如我在调试器中看到的那样，数组已排序。我将两个整数的输出相加，再看看。
已编辑 23/05/12 16:46 UTC+1
我正在改变整个事情以使用来自 JDK 1.7 的新的、非常简单的 ForkJoinPool。使用最多 10 个 mio 整数的整数数组进行测试，得到了有趣的结果：我在 Core2Duo (2010) MacBook Pro 和 Core-i5 (2011) Windows 7 上对其进行了测试：
core2duo 和 i5 可以进行超线程，所以我现在使用 availableProcessors()*2 进行了测试 -> core2duo 的 2 个线程加速到 1.8 和 1.7 得到了一点提升；i5 目前的加速比约为 3.2，每个 availableProcessors()*2 最多 8 个线程
还在用我的机器做实验。所有测试均使用相同的数组完成，平均值是根据每个数组大小的 1000 次排序迭代计算得出的。