Java 多线程排序算法

我必须在Java中为我的算法类实现多线程合并排序和快速排序，并将它们与我的单线程版本进行比较。但是，我以前从未使用过多线程

我的代码可以是多线程的还是必须重新开始

这是我的单线程算法代码 合并排序。sort（）方法是我必须实现的策略模式的一部分

    @Override
public int[] sort(int[] list) {
    int array_size = list.length;
    list = msort(list, 0, array_size-1);
    return list;
}

int[] msort(int numbers[], int left, int right) {
    int mid;
    if (left<right) {
        mid = (right + left) / 2;
        msort(numbers, left, mid);
        msort(numbers, mid+1, right);
        merge(numbers, left, mid, mid+1, right);
    }
    return numbers;
}

void merge(int numbers[], int startA, int endA, int startB, int endB) {
    int finalStart = startA;
    int finalEnd = endB;
    int indexC = 0;
    int[] listC = new int[numbers.length];

    while(startA <= endA && startB <= endB){
        if(numbers[startA] < numbers[startB]){
            listC[indexC] = numbers[startA];
            startA = startA+1;
        }
        else{
            listC[indexC] = numbers[startB];
            startB = startB +1;
        }
        indexC++;
    }

    if(startA <= endA){
        for(int i = startA; i < endA; i++){
            listC[indexC]= numbers[i];
            indexC++;
        }
    }

    indexC = 0;
    for(int i = finalStart; i <= finalEnd; i++){
        numbers[i]=listC[indexC];
        indexC++;
    }
}

@覆盖
公共int[]排序（int[]列表）{
int array_size=list.length；
列表=msort（列表，0，数组大小-1）；
退货清单；
}
int[]msort（int编号[]，int左，int右）{
int mid；
如果（左简短回答-是，这些算法可以转换为多线程，而无需从头开始（据我所知）

使这些“易于”并行化的关键要素包括：


每个实现中有两个递归调用
这两个递归调用对不同的数据段进行操作-它们不应该相互冲突（例如，即使在同一数组中工作，它们也对不同的索引进行操作）
在两个递归调用都完成之前，进行这些递归调用的方法无法继续
这两个电话的顺序都不重要

希望这回答了你的一些问题


还有一些建议，不确定这是否有用：


如果将两个递归调用放入一个新线程，那么当前线程在等待它们完成时将处于空闲状态
当需要处理的元件数量较少时，线程的开销可能高于增益
通常，您可能希望限制用于此任务的线程数-您可能希望使用某种形式的线程池或工作队列，并使用固定数量的线程
在这种情况下，一个主要的建议（我在你的位置上犯了一个错误，我看到很多其他人也犯了这个错误）是不要让线程的数量不受限制地增长。请记住，如果每个递归分支启动一个线程，主线程将生成一个子线程（假设在主线程本身上完成一个递归调用），子线程将生成一个额外的线程，依此类推，直到您的数据集较大时阻塞系统

一个更明确的替代方法是，每次递归调用启动一个线程，这样每个线程生成两个子线程，然后将它们连接起来

无论哪种方式，都要确保对产生线程的递归深度设置一个限制（比如等于CPU内核的数量）如果超出了限制，请按顺序调用其余级别的排序方法。
嘿，米奇，我不记得曾要求任何人为我编写代码。感谢你花时间发布想法抱歉，我非常感谢你的回答。关于OP的另一个建议：如果你的课堂作业允许，它将使用a并在那里提交单个任务相对简单。这样，您就不必关心创建线程和在线程之间分配任务。只需使用线程池即可。该算法不会生成线程，它只是对工作项进行排队，这些工作项由n个线程解析，其中n是一个配置属性。然后，您将继续rol你有多少平行度。
    @Override
public int[] sort(int[] list) {
    int[] array = quickSort(list, 0, list.length-1);
    return array;
}
int partition(int arr[], int left, int right)
{
      int i = left, j = right;
      int tmp;
      int pivot = arr[(left + right) / 2];

      while (i <= j) {
            while (arr[i] < pivot)
                  i++;
            while (arr[j] > pivot)
                  j--;
            if (i <= j) {
                  tmp = arr[i];
                  arr[i] = arr[j];
                  arr[j] = tmp;
                  i++;
                  j--;
            }
      };

      return i;
}

int[] quickSort(int arr[], int left, int right) {
      int index = partition(arr, left, right);
      if (left < index - 1)
            quickSort(arr, left, index - 1);
      if (index < right)
            quickSort(arr, index, right);
      return arr;
}