并发线程合并排序

Question

I have to code a concurrent Merge Sort Aplication. Every time the array gets split up, I have to create a new thread for the right half (max. Number of Threads is 5 -> so 5 Times) which continues the Mergesort algorithm.

That's my program:

class Mergesorts implements Runnable{

    private int[] internal;

    Mergesorts(int[] arr) {
        internal = arr;
    }

    private void processCommand(int [] array) {
        if (array.length > 1) { 
            int[] left = leftHalf(array);
            int[] right = rightHalf(array);
            processCommand(left);
            processCommand(right);
            merge(array, left, right);
        }
    }

    public int[] rightHalf(int[] array) {
        int size1 = array.length / 2;
        int size2 = array.length - size1;
        int[] right = new int[size2];
        for (int i = 0; i < size2; i++) {
            right[i] = array[i + size1];
        }
        return right;
    }

    public void run() {
        processCommand(internal);
    }
}

How can I rewrite my code to sort concurrently as described above?

How can i edit my code so it only creates up to 5 Threads and not more?

private void processCommand(int [] array) {
    if (array.length > 1) {


        int[] right = rightHalf(array);
        int[] left = leftHalf(array);


        Mergesorts worker2 = new Mergesorts(right);
        Thread s = new Thread(worker2);
        s.start();

        processCommand(left);

        try {
            s.join();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        merge(array, left, right);}

}

Answer 1

Start the new thread in the processCommand() method, not in the rightHalf() method. If you have threads available, then instead of the line calling processCommand(right), construct a new Mergesorts object on right and start a thread with it. Don't forget to call join() on the thread to ensure it completes before doing the merge.

To improve parallelism, you can start the new thread on the right half of the array before processing the left half of the array, so both are done at the same time - that is, move processCommand(left) to after the block that either does processCommand(right) or starts a new thread. The join() call should be after both halves are done, but before the merge.

Edit: you are getting closer; to address your comment, you need something like this:

private void processCommand(int [] array) {
    if (array.length <= 1)
        {return;}

    int[] left = leftHalf(array);
    int[] right = rightHalf(array);
    Thread rightThread = null;

    if (b <= 5) {
        ++b;
        Mergesorts worker = new Mergesorts(right);
        rightThread = new Thread(worker);
        rightThread.start();
    } else {
        processCommand(right);
    }

    processCommand(left);

    if (null != rightThread) {
        try {
            rightThread.join();
            b--
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            // better error handling would be good
        }
    }

    merge(array, left, right);
}

b also needs to be volatile to ensure the different threads can see how many threads are currently executing.