为什么我的多线程排序算法不比我的单线程归并排序快

Question

当一个人分割一个任务并让每个部分并行完成时，某些算法的运行时间会显着减少。其中一种算法是归并排序，其中一个列表被分成无限小的部分，然后按排序顺序重新组合。我决定做一个实验来测试我是否可以通过使用多个线程来提高这种排序的速度。我在装有 Windows Vista 的四核戴尔上用 Java 运行以下功能。

一个函数（控制用例）是简单的递归：

// x is an array of N elements in random order
public int[] mergeSort(int[] x) {
    if (x.length == 1) 
        return x;

    // Dividing the array in half
    int[] a = new int[x.length/2];
    int[] b = new int[x.length/2+((x.length%2 == 1)?1:0)];
    for(int i = 0; i < x.length/2; i++) 
        a[i] = x[i];
    for(int i = 0; i < x.length/2+((x.length%2 == 1)?1:0); i++) 
        b[i] = x[i+x.length/2];

    // Sending them off to continue being divided
    mergeSort(a);
    mergeSort(b);

    // Recombining the two arrays
    int ia = 0, ib = 0, i = 0;
    while(ia != a.length || ib != b.length) {
        if (ia == a.length) {
            x[i] = b[ib];
            ib++;
        }
        else if (ib == b.length) {
            x[i] = a[ia];
            ia++;
        }
        else if (a[ia] < b[ib]) {
            x[i] = a[ia];
            ia++;
        }
        else {
            x[i] = b[ib];
            ib++;
        }
        i++;
    }

    return x;
}

另一个是在一个扩展线程的类的'run'函数中，每次调用都会递归创建两个新线程：

public class Merger extends Thread
{
    int[] x;
    boolean finished;

    public Merger(int[] x)
    {
        this.x = x;
    }

    public void run()
    {
        if (x.length == 1) {
            finished = true;
            return;
        }

        // Divide the array in half
        int[] a = new int[x.length/2];
        int[] b = new int[x.length/2+((x.length%2 == 1)?1:0)];
        for(int i = 0; i < x.length/2; i++) 
            a[i] = x[i];
        for(int i = 0; i < x.length/2+((x.length%2 == 1)?1:0); i++) 
            b[i] = x[i+x.length/2];

        // Begin two threads to continue to divide the array
        Merger ma = new Merger(a);
        ma.run();
        Merger mb = new Merger(b);
        mb.run();

        // Wait for the two other threads to finish 
        while(!ma.finished || !mb.finished) ;

        // Recombine the two arrays
        int ia = 0, ib = 0, i = 0;
        while(ia != a.length || ib != b.length) {
            if (ia == a.length) {
                x[i] = b[ib];
                ib++;
            }
            else if (ib == b.length) {
                x[i] = a[ia];
                ia++;
            }
            else if (a[ia] < b[ib]) {
                x[i] = a[ia];
                ia++;
            }
            else {
                x[i] = b[ib];
                ib++;
            }
            i++;
        }

        finished = true;
    }
}

事实证明，不使用多线程的函数实际上运行得更快。为什么？操作系统和 java 虚拟机是否没有足够有效地“通信”以将不同的线程放在不同的内核上？还是我遗漏了一些明显的东西？

Answer 1

问题不在于多线程：我已经用 Java 编写了正确的多线程 QuickSort，它拥有默认的 Java 排序。我是在目睹一个巨大的数据集正在处理并且只有一个 16 核机器的一个核心在工作之后才这样做的。

您的一个问题（一个大问题）是您正忙于循环：

 // Wait for the two other threads to finish 
 while(!ma.finished || !mb.finished) ;

这是一个巨大的禁忌：它被称为忙循环，你正在破坏性能。

（另一个问题是您的代码没有产生任何新线程，正如已经向您指出的那样）

您需要使用其他方式进行同步：例如使用CountDownLatch。

另一件事：划分工作负载时不需要生成两个新线程：只生成一个新线程，在当前线程中执行另一半。

另外，您可能不想创建比可用内核更多的线程。

在这里查看我的问题（要求一个好的开源多线程合并排序/快速排序/其他）。我用的是专有的，我不能粘贴。

Multithreaded quicksort or mergesort

我还没有实现 Mergesort，但是 QuickSort，我可以告诉你，没有数组复制正在进行。

我要做的是：

• 选择一个支点
• 根据需要交换值
• 我们是否达到线程限制？ （取决于核心数）
  • 是：对本帖的第一部分进行排序
  • 否：产生一个新线程
• 对当前线程中的第二部分进行排序
• 如果第一部分尚未完成，请等待它完成（使用 CountDownLatch）。

产生一个新线程并创建 CountDownLatch 的代码可能如下所示：

            final CountDownLatch cdl = new CountDownLatch( 1 );
            final Thread t = new Thread( new Runnable() {
                public void run() {
                    quicksort(a, i+1, r );
                    cdl.countDown();
                }
            } };

使用 CountDownLatch 等同步工具的优势在于它非常高效，而且您不会浪费时间处理低级 Java 同步特性。

在您的情况下，“拆分”可能如下所示（未经测试，只是提供一个想法）：

if ( threads.getAndIncrement() < 4 ) {
    final CountDownLatch innerLatch = new CountDownLatch( 1 );
    final Thread t = new Merger( innerLatch, b );
    t.start();
    mergeSort( a );
    while ( innerLatch.getCount() > 0 ) {
        try {
            innerLatch.await( 1000, TimeUnit.SECONDS );
        } catch ( InterruptedException e ) {
            // Up to you to decide what to do here
        }
    }
} else {
    mergeSort( a );
    mergeSort( b );
}

（不要忘记在每次合并完成时对锁存器“倒计时”）

您可以将线程数（此处最多 4 个）替换为可用内核数。您可以使用以下内容（例如，在程序开始时初始化一些静态变量：内核数量不太可能改变[除非您使用的机器允许像某些 Sun 系统允许的那样 CPU 热交换]）：

Runtime.getRuntime().availableProcessors()

Answer 2

正如其他人所说；这段代码不起作用，因为它没有启动新线程。您需要调用 start() 方法而不是 run() 方法来创建新线程。它也有并发错误：对finished变量的检查不是线程安全的。

如果您不了解基础知识，并发编程可能会非常困难。您可能会阅读本书Java Concurrency in Practice by Brian Goetz。它解释了基础知识并解释了构造（例如 Latch 等）以简化构建并发程序。

Answer 3

同步的开销成本可能比较大，会阻碍很多优化。

此外，您创建的线程太多。

另一个是在扩展线程的类的“运行”函数中，在每次调用时递归地创建两个新线程。

使用固定数量的线程会更好，建议在四核上使用 4 个。这可以通过线程池 (tutorial) 来实现，模式将是“任务包”。但也许更好的是，最初将任务分成四个同样大的任务，并对这些任务进行“单线程”排序。这样可以更好地利用缓存。

---

您应该查看Thread.join()，而不是等待线程完成的“忙循环”（窃取 cpu 周期）。

Answer 4

您必须对数组中的多少个元素进行排序？如果元素太少，同步和 CPU 切换的时间将超过您为并行划分作业而节省的时间