java - 使用两个线程进行交换

Question

在学习多线程的过程中，我教解决下面提到的问题

您有一个按升序排列的字母字符串数组，最后一个位置为空。

有 2 个线程处理字母表的交换，一个线程从前面取出字母(即“a”)并与空位交换，而第二个线程从最后一个字母(即“z”)取出字母并移动它到前面的空位

Input:- ABCDEFGHIJKLMNOPQRSTUVWXYZ_
Ouput:-ZYXWVUTSRQPON_MLKJIHGFEDCBA

下面是我针对这个问题编写的程序。但我需要知道是否有更好的方法来实现同样的目标。

//阿尔法交换

public class AlphaSwap {

    String input[] = { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s",
            "t", "u", "v", "w", "x", "y", "z", "_" };
    int start = 0;
    int end = 26;
    boolean flag;

    private String[] swap(String input[], int start, int end) {
        String temp = input[start];
        input[start] = input[end];
        input[end] = temp;

        return input;
    }

    public synchronized void swapLast(String input[]) {
        if( flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        String[] swap = swap(input, start, end);
        System.out.println(Thread.currentThread().getName());
        for (String string : swap) {
            System.out.print(string);
        }
        System.out.println();
        this.end--;
        flag = true;
        notify();
    }

    public synchronized void swapFirst(String input[]) {
        if(!flag){
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        String[] swap = swap(input, start, end);
        System.out.println(Thread.currentThread().getName());
        for (String string : swap) {
            System.out.print(string);
        }
        System.out.println();
        this.start++;
        flag = false;
        notify();
    }


}

//Runner主类

public class RunnerMain {
    public static void main(String[] args) {
        AlphaSwap alphaSwap = new AlphaSwap();

        new SwapLast(alphaSwap);
        new SwapFirst(alphaSwap);
    }
}

//先交换

public class SwapFirst implements Runnable{

    private AlphaSwap swap;

    public SwapFirst(AlphaSwap swap) {
        this.swap = swap;
        new Thread(this).start();
    }

    @Override
    public void run() {
            for (int i = 0; i < 13; i++) {
                swap.swapFirst(swap.input);
        }
    }
}

//最后一次交换

public class SwapLast implements Runnable {
    private AlphaSwap swap;

    public SwapLast(AlphaSwap swap) {
        this.swap = swap;
        new Thread(this).start();
    }

    @Override
    public void run() {
            for (int i = 0; i < 13; i++) {
                swap.swapLast(swap.input);
        }
    }

}

上面的代码还有什么可以改进的地方吗？

Answer 1

事实上，经过思考，有一个并行工作的交换算法，但它不是你的

void swapThread(Object array[], int offset, int step) {
    int index = offset;
    while(index < array.size()/2) {
        Object temp = array[index];
        array[index] = array[array.size()-1-index]; 
        array[array.size()-1-index] = temp;
        index += step;
    }
}

您可以使用step作为正在运行的线程数来调用该函数，并且每个线程具有从0到线程数-1的不同偏移量。

例如，对于 4 个线程，您将有 4 个线程调用

swapThread(array, 0, 4);
swapThread(array, 1, 4);
swapThread(array, 2, 4);
swapThread(array, 3, 4);

该算法更好的一个重要原因是它可以运行任意数量的线程，并且没有一个线程在相同的索引上运行，因此不存在竞争条件的可能性。