Java整数比较：大于

Question

我有一个包含一百万个整数的数组，因为我正在尝试并行快速排序。 我有时会出现以下奇怪的行为：

为了检查数组是否正确排序，我在排序后输入了以下代码：

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% 确定它可能是什么并发，正如我在调试器中看到的那样，数组已排序。我将两个整数的输出相加，再看看。

于 2012 年 5 月 23 日 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 次排序迭代计算得出的。

Answer 1

查看您的代码，您生成了一个线程，然后立即将其加入主执行线程：

        Thread t1 = new Thread(new Quicksort_Parallel(0, array_parallel.length-1, array_parallel));

        sp_parallel.setStart(System.currentTimeMillis());
        t1.start();

        try {
            t1.join();

问题变成了 - 您在 Quicksort_Parallel 例程中做什么？你是否产生了额外的线程？您是否正在加入所有？如果不是，您已经创建了一个竞争条件来解释您所看到的结果。

Answer 2

您可能是竞争条件的受害者，这意味着您的输出取决于其他事件的顺序。因此，如果您有一个工作速度更快的线程，您将获得竞争条件。阻止这种情况的一种方法是使用信号量或在线程之间划分循环。你怎么样？你在使用减法吗？

Answer 3

如果您使用的是 Java SE 7，请考虑使用新的 fork/join API：

http://docs.oracle.com/javase/tutorial/essential/concurrency/forkjoin.html

http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ForkJoinPool.html

http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ForkJoinTask.html

http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ForkJoinWorkerThread.html