Question

我已经使用多线程实现了快速排序，它正确地对整数数组进行排序，但是执行时需要比正常的快速排序更长的时间。例如，对10000个整数进行排序多线程：6856毫秒正常：1毫秒

我不知道我的代码有什么问题。

public void run()
{
    quickSort1(this.Array,this.low,this.high);
}
int partition(int[]A,int l,int r)
  {
    int v = A[r];
    int i = l;
    int j = r;

    while(i<j)
    {
        while(A[i]<v)
        {
            i++;
        }

        while((i<j)&&(A[j]>=v))
        {
            j--;
        }

        if(i<j)
        {
            int C = A[i];


            A[i] = A[j];
            A[j] = C;
        }

        else
        {
            int D = A[i];

            A[i] = A[r];
            A[r] = D;
        }
    }


    return i;
}



void quickSort1(int[] A,int l,int r)
{
    int i;
    if(r>l)
    {
        i = partition(A,l,r);

        quickSort sort1 = new quickSort(A,l,i-1);
        Thread t1 = new Thread(sort1);


        quickSort sort2 = new quickSort(A,i+1,r);
        Thread t2 = new Thread(sort2);
        t1.start();
        t2.start();

        try
        {
            t1.join();
            t2.join();
        }catch(Exception e){}



    }
}

void normal_quickSort(int[] A,int l,int r)
{

    int i;
    if(r>l)
    {
        i = partition(A,l,r);

        normal_quickSort(A,l,i-1);
        normal_quickSort(A,i+1,r);
    }
}

Answer 1

两个问题，

（1）您创建了太多线程。创建线程很昂贵。对于计算绑定任务，如果您创建的线程总数大于平台中的CPU数，则可能会出错。

诀窍是 pool 线程。（例如，创建一个java.util.concurrent.ThreadPoolExecutor，并为其执行任务。

（2）你正在把工作分解成太小的任务。同步线程和在线程之间传递数据也很昂贵。不像创建和销毁线程那么昂贵，但是你想要做多少次仍然是一个限制。

您的算法可能会将工作划分到您为线程提供一个元素列表的位置，并要求线程排序＆＃34;排序＆＃34;它。这对于多线程来说是一项非常小的任务。

要实现快速排序，您必须将阵列分成更小和更小的块，但是您不必将每个块分配给不同的线程，并且在它们变得足够小之后，您不应该这样做。。我不知道它有多小（100？1000？10,000？），但你可以很容易地试验一下。

多线程QuickSort比普通QuickSort更长时间

1 个答案: