Java 多线程合并排序，添加其他线程

我在java的多线程合并排序算法中面临一个问题

我应该通过将原始数组划分为

子数组

s，将代码修改为3,4,5,6,7,8线程合并排序。目前它有2个子阵列。 如何将原始阵列拆分为3、4、5、6、7、8

子阵列来实现我的目标？
此外，我应该编写更多的方法，因为
mergeSort
method此时调用
lefthalf
和
righhalf
方法。因此，对于3,4,5,6,7,8线程，我应该编写额外的方法。
我该怎么办

双线程\u合并\u排序.java

public class two_threaded_merge_sort {

public static void finalMerge(int[] a, int[] b) {
    int[] result = new int[a.length + b.length];
    int i=0; 
    int j=0; 
    int r=0;
    while (i < a.length && j < b.length) {
        if (a[i] <= b[j]) {
            result[r]=a[i];
            i++;
            r++;
        } else {
            result[r]=b[j];
            j++;
            r++;
        }
        if (i==a.length) {
            while (j<b.length) {
                result[r]=b[j];
                r++;
                j++;
            }
        }
        if (j==b.length) {
            while (i<a.length) {
                result[r]=a[i];
                r++;
                i++;
            }
        }
    }
}

public static void main(String[] args) throws InterruptedException {
    Random rand = new Random();
    int[] original = new int[9000000];
    for (int i=0; i<original.length; i++) {
        original[i] = rand.nextInt(1000);
    }

    long startTime = System.currentTimeMillis();
    int[] subArr1 = new int[original.length/2];
    int[] subArr2 = new int[original.length - original.length/2];
    System.arraycopy(original, 0, subArr1, 0, original.length/2);
    System.arraycopy(original, original.length/2, subArr2, 0, original.length - original.length/2);

    Worker runner1 = new Worker(subArr1);
    Worker runner2 = new Worker(subArr2);
    runner1.start();
    runner2.start();
    runner1.join();
    runner2.join();
    finalMerge (runner1.getInternal(), runner2.getInternal());
    long stopTime = System.currentTimeMillis();
    long elapsedTime = stopTime - startTime;
    System.out.println("2-thread MergeSort takes: " + (float)elapsedTime/1000 + " seconds");
}

}

public class two\u threaded\u merge\u sort{
公共静态无效最终合并（int[]a，int[]b）{
int[]结果=新int[a.length+b.length]；
int i=0；
int j=0；
int r=0；
而（i如果（a[i]需要一个排序函数将数组分成k个部分，那么创建k个线程来对每个部分进行排序，使用自顶向下或自底向上的方法（自底向上的速度稍快），并等待所有线程完成

此时有k个排序的部分。可以使用k路合并（复杂）一次合并所有这些部分，或者一次合并一对部分（2路合并），可能使用多个线程，但此时进程可能内存带宽有限，因此多线程可能没有多大帮助

将阵列分成k个部分时，可以使用类似的方法来保持大小相似：

int r = n % k;
int s = n / k;
int t;
for each part{
    t = r ? 1 : 0;
    r -= t;
    size = s + t;
}

或

在我看来，你的努力已经完成了。现在你必须用线程数来参数化算法

您的算法有两部分

分工合作
合并k部分
和两个组件：

主算法
工人
关于线程

在我看来，Start/join方法在这种情况下没有用处，因为在所有线程完成之前，最后一次合并无法启动。我更喜欢“双向合并”（@rcgldr-answer）和线程池（ExecutorService）。
您必须小心线程同步和共享内存

总而言之，我提出了一个稍微不同的解决方案：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

public class MultithreadedMergeSort {

    private int[] array;
    private int numThreads;
    private List<int[]> sortedFragments;

    private MultithreadedMergeSort(int numThreads, int[] array) {
        this.numThreads = numThreads;
        this.array = array;
    }

    // Basic algorithm: it sort recursively a fragment
    private static void recursiveMergeSort(int[] array, int begin, int end) {
        if (end - begin > 1) {
            int middle = (begin + end) / 2;
            recursiveMergeSort(array, begin, middle);
            recursiveMergeSort(array, middle, end);
            merge(array, begin, middle, end);
        }
    }

    // Basic algorithm: it merges two consecutives sorted fragments
    private static void merge(int[] array, int begin, int middle, int end) {
        int[] firstPart = Arrays.copyOfRange(array, begin, middle);
        int i = 0;
        int j = middle;
        int k = begin;
        while (i < firstPart.length && j < end) {
            if (firstPart[i] <= array[j]) {
                array[k++] = firstPart[i++];
            } else {
                array[k++] = array[j++];
            }
        }
        if (i < firstPart.length) {
            System.arraycopy(firstPart, i, array, k, firstPart.length - i);
        }
    }

    public static void sort(int[] array, int numThreads) throws InterruptedException {
        if (array != null && array.length > 1) {
            if (numThreads > 1) {
                new MultithreadedMergeSort(numThreads, array).mergeSort();
            } else {
                recursiveMergeSort(array, 0, array.length);
            }
        }
    }

    private synchronized void mergeSort() throws InterruptedException {
        // A thread pool
        ExecutorService executors = Executors.newFixedThreadPool(numThreads);
        this.sortedFragments = new ArrayList<>(numThreads - 1);
        int begin = 0;
        int end = 0;

        // it split the work
        for (int i = 1; i <= (numThreads - 1); i++) {
            begin = end;
            end = (array.length * i) / (numThreads - 1);
            // sending the work to worker
            executors.execute(new MergeSortWorker(begin, end));
        }
        // this is waiting until work is done
        wait();

        // shutdown the thread pool.
        executors.shutdown();
    }

    private synchronized int[] notifyFragmentSorted(int begin, int end) {
        if (begin > 0 || end < array.length) {
            // the array is not completely sorted

            Iterator<int[]> it = sortedFragments.iterator();
            // searching a previous or next fragment
            while (it.hasNext()) {
                int[] f = it.next();
                if (f[1] == begin || f[0] == end) {
                    // It found a previous/next fragment
                    it.remove();
                    return f;
                }
            }
            sortedFragments.add(new int[]{begin, end});
        } else {
            // the array is sorted
            notify();
        }
        return null;
    }

    private class MergeSortWorker implements Runnable {

        int begin;
        int end;

        public MergeSortWorker(int begin, int end) {
            this.begin = begin;
            this.end = end;
        }

        @Override
        public void run() {
            // Sort a fragment
            recursiveMergeSort(array, begin, end);
            // notify the sorted fragment
            int[] nearFragment = notifyFragmentSorted(begin, end);

            while (nearFragment != null) {
                // there's more work: merge two consecutives sorted fragments, (begin, end) and nearFragment
                int middle;
                if (nearFragment[0] < begin) {
                    middle = begin;
                    begin = nearFragment[0];
                } else {
                    middle = nearFragment[0];
                    end = nearFragment[1];
                }
                merge(array, begin, middle, end);
                nearFragment = notifyFragmentSorted(begin, end);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        int numThreads = 5;

        Random rand = new Random();
        int[] original = new int[9000000];
        for (int i = 0; i < original.length; i++) {
            original[i] = rand.nextInt(1000);
        }

        long startTime = System.currentTimeMillis();

        MultithreadedMergeSort.sort(original, numThreads);

        long stopTime = System.currentTimeMillis();
        long elapsedTime = stopTime - startTime;
        // warning: Take care with microbenchmarks
        System.out.println(numThreads + "-thread MergeSort takes: " + (float) elapsedTime / 1000 + " seconds");
    }
}

import java.util.ArrayList；
导入java.util.array；
导入java.util.Iterator；
导入java.util.List；
导入java.util.Random；
导入java.util.concurrent.Executors；
导入java.util.concurrent.ExecutorService；
公共类多线程mergesort{
私有int[]数组；
私有int numThreads；
私人名单分类碎片；
私有多线程mergesort（int numThreads，int[]数组）{
this.numThreads=numThreads；
this.array=数组；
}
//基本算法：对一个片段进行递归排序
私有静态void recursiveMergeSort（int[]数组、int-begin、int-end）{
如果（结束-开始>1）{
中间整数=（开始+结束）/2；
递归合并排序（数组、开始、中间）；
递归合并排序（数组、中间、结束）；
合并（数组、开始、中间、结束）；
}
}
//基本算法：它合并两个连续排序的片段
私有静态无效合并（int[]数组、int begin、int middle、int end）{
int[]firstPart=Arrays.copyOfRange（array，begin，middle）；
int i=0；
int j=中间；
int k=开始；
而（i1）{
新的多线程mergeSort（numThreads，array）.mergeSort（）；
}否则{
递归合并排序（数组，0，array.length）；
}
}
}
private synchronized void mergeSort（）引发InterruptedException{
//线程池
ExecutorService executors=executors.newFixedThreadPool（numThreads）；
this.sortedFragments=newArrayList（numThreads-1）；
int begin=0；
int end=0；
//它分散了工作
for（int i=1；i 0 | | endint r = n % k;
int s = n / k + 1;
while(r--){
   next part size = s; // n / k + 1
}
s -= 1;
while not done{
   next part size = s; // n / k
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.Random;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;

public class MultithreadedMergeSort {

    private int[] array;
    private int numThreads;
    private List<int[]> sortedFragments;

    private MultithreadedMergeSort(int numThreads, int[] array) {
        this.numThreads = numThreads;
        this.array = array;
    }

    // Basic algorithm: it sort recursively a fragment
    private static void recursiveMergeSort(int[] array, int begin, int end) {
        if (end - begin > 1) {
            int middle = (begin + end) / 2;
            recursiveMergeSort(array, begin, middle);
            recursiveMergeSort(array, middle, end);
            merge(array, begin, middle, end);
        }
    }

    // Basic algorithm: it merges two consecutives sorted fragments
    private static void merge(int[] array, int begin, int middle, int end) {
        int[] firstPart = Arrays.copyOfRange(array, begin, middle);
        int i = 0;
        int j = middle;
        int k = begin;
        while (i < firstPart.length && j < end) {
            if (firstPart[i] <= array[j]) {
                array[k++] = firstPart[i++];
            } else {
                array[k++] = array[j++];
            }
        }
        if (i < firstPart.length) {
            System.arraycopy(firstPart, i, array, k, firstPart.length - i);
        }
    }

    public static void sort(int[] array, int numThreads) throws InterruptedException {
        if (array != null && array.length > 1) {
            if (numThreads > 1) {
                new MultithreadedMergeSort(numThreads, array).mergeSort();
            } else {
                recursiveMergeSort(array, 0, array.length);
            }
        }
    }

    private synchronized void mergeSort() throws InterruptedException {
        // A thread pool
        ExecutorService executors = Executors.newFixedThreadPool(numThreads);
        this.sortedFragments = new ArrayList<>(numThreads - 1);
        int begin = 0;
        int end = 0;

        // it split the work
        for (int i = 1; i <= (numThreads - 1); i++) {
            begin = end;
            end = (array.length * i) / (numThreads - 1);
            // sending the work to worker
            executors.execute(new MergeSortWorker(begin, end));
        }
        // this is waiting until work is done
        wait();

        // shutdown the thread pool.
        executors.shutdown();
    }

    private synchronized int[] notifyFragmentSorted(int begin, int end) {
        if (begin > 0 || end < array.length) {
            // the array is not completely sorted

            Iterator<int[]> it = sortedFragments.iterator();
            // searching a previous or next fragment
            while (it.hasNext()) {
                int[] f = it.next();
                if (f[1] == begin || f[0] == end) {
                    // It found a previous/next fragment
                    it.remove();
                    return f;
                }
            }
            sortedFragments.add(new int[]{begin, end});
        } else {
            // the array is sorted
            notify();
        }
        return null;
    }

    private class MergeSortWorker implements Runnable {

        int begin;
        int end;

        public MergeSortWorker(int begin, int end) {
            this.begin = begin;
            this.end = end;
        }

        @Override
        public void run() {
            // Sort a fragment
            recursiveMergeSort(array, begin, end);
            // notify the sorted fragment
            int[] nearFragment = notifyFragmentSorted(begin, end);

            while (nearFragment != null) {
                // there's more work: merge two consecutives sorted fragments, (begin, end) and nearFragment
                int middle;
                if (nearFragment[0] < begin) {
                    middle = begin;
                    begin = nearFragment[0];
                } else {
                    middle = nearFragment[0];
                    end = nearFragment[1];
                }
                merge(array, begin, middle, end);
                nearFragment = notifyFragmentSorted(begin, end);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        int numThreads = 5;

        Random rand = new Random();
        int[] original = new int[9000000];
        for (int i = 0; i < original.length; i++) {
            original[i] = rand.nextInt(1000);
        }

        long startTime = System.currentTimeMillis();

        MultithreadedMergeSort.sort(original, numThreads);

        long stopTime = System.currentTimeMillis();
        long elapsedTime = stopTime - startTime;
        // warning: Take care with microbenchmarks
        System.out.println(numThreads + "-thread MergeSort takes: " + (float) elapsedTime / 1000 + " seconds");
    }
}