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

我在启动并行排序的线程上进行连接。第一个Thread同时最多生成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 - ＆gt;进行测试。 core2duo对于2个线程的加速有点提升到1.8和1.7; i5目前的速度为3.2，每个可用处理器（）* 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

Java整数比较：大于

3 个答案: