Question

我一直在尝试使用java编写多线程快速排序程序。网上有很多使用ThreadPool，CountDownLatch等的示例。

但是，我只想使用计数来保持创建的线程数。

该计划背后的逻辑是：

1.  The main thread calls the parallel quicksort method
2.  The method partitions the array and check for the number of current threads
3.  Spawn new threads for next step using the same parallel method
4.  Or use the single normal quicksort method

我使用并行方式获得了性能，但并没有那么多。有人可以帮我改进代码吗？

这就是我所做的：

class Quicksort extends Thread {
        private int arr[];
        private int low,high;
        public static int numThreads = Runtime.getRuntime().availableProcessors();
        public static int count = 0;

        public Quicksort(int[] arr, int low, int high){
            this.arr = arr;
            this.low = low;
            this.high = high;
        }

        public void run(){
            parallelQuicksort(arr,low,high);    
        }

        public static void quicksort(int[] arr, int low, int high){
            if (high>low){
                int i = partition(arr,low,high);
                quicksort(arr,low,i-1);
                quicksort(arr,i+1,high);
            }
        }

        public static  void parallelQuicksort(int[] arr, int low, int high){
            if (high>low){
                int i = partition(arr,low,high);
                if (count < numThreads){
                    count++;
                    Quicksort quicksort  = new Quicksort(arr, low, i-1);
                    quicksort.start();
                    try{
                        quicksort.join();
                    }
                    catch (InterruptedException e){}
                }
                else{
                    quicksort(arr,low,i-1);
                }   
                if (count < numThreads){
                    count++;
                    Quicksort quicksort  = new Quicksort(arr, i+1, high);
                    quicksort.start();
                    try{
                        quicksort.join();
                    }
                    catch (InterruptedException e){}
                }
                else{
                    quicksort(arr,i+1,high);
                }   
            }
        }

        public static int partition(int[] A, int l,int r)

        public static void swap(int[] A,int i,int j)

        public static int median(int[] A,int l,int mid,int r)
}

主要班级：

public class Test{
    public static void main(String[] args) {
    //generate random array of size 1000000

    long start = System.currentTimeMillis();

    Quicksort.quicksort(arr,0,arr.length -1);

    System.out.println("Single array sorted in "+(System.currentTimeMillis()-start)+" ms");

    start = System.currentTimeMillis();

    Quicksort.parallelQuicksort(arr2,0,arr.length -1);

    System.out.println("Threaded array sorted in "+(System.currentTimeMillis()-start)+" ms");
    }
}

我得到的样本输出：

Single array sorted in 393 ms
Threaded array sorted in 367 ms

Single array sorted in 325 ms
Threaded array sorted in 305 ms

Single array sorted in 344 ms
Threaded array sorted in 320 ms

Answer 1

这里最大的问题是你在开始一个新线程后正在加入。这会导致调用线程等待新线程完成。您需要启动您打算同时运行的所有线程，然后在它们全部运行后等待它们。所以而不是：

Quicksort quicksort  = new Quicksort(arr, low, i-1);
quicksort.start();  // Start new thread.
quickstart.join();  // Wait for it to run before moving on

Quicksort quicksort = new Quicksort(arr, i+1, high);
quickstart.start(); // Start second thread (after first has finished)
quickstart.join(); // Wait for second thread.

你需要做更多这样的事情：

Quicksort low = new Quicksort(arr, low, i-1);
low.start(); // Start first thread
Quicksort high = new Quicksort(arr, i+1, high);
high.start(); // While first thread is running, start second.
low.join(); // Wait for first thread.
high.join(); // Immediately returns if already finished

上面的代码，我认为你打算写的，仍然是低效的。在等待其他线程完成时，它不会将任何工作分配给主线程。

除了这些问题，你编写它的方式，一旦一个线程完成，计数不会减少。相反，主线程只会获得更多的工作。这意味着您没有正确分配负载。

正如@Sergei在评论中所说，您可能希望查看Fork / Join框架来管理线程。 Fork / Join in Java允许您将工作拆分为任务，并将它们排队，以便将它们分配给备用线程。如果要限制所使用的线程数，可以通过在创建ForkJoinPool时设置所需的并行度来实现。

ForkJoinPool pool = new ForkJoinPool(numThreads);

虽然，defaut设置为可用处理器的数量，除非你有理由改变它，否则不要。

有关如何使用Java Fork / Join库编写快速排序的教程here。

另一方面，您过度使用static方法。它们应该是实例方法。有关何时使用静态方法的详细信息，请查看here。

java中的多线程快速排序

1 个答案: