Question

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

你有一个按字母顺序排列的字符串数组，最后一个字是空的。

有2个线程处理字母表的交换，一个线程从前面取信（即'a'）并与空白点交换，而第二个线程从最后一个（即'z'）取信并移动它到了前面的空位

输入： - ABCDEFGHIJKLMNOPQRSTUVWXYZ_
的输出继电器： - ZYXWVUTSRQPON_MLKJIHGFEDCBA

以下是我遇到此问题的程序。但我需要知道是否有更好的方法来实现同样的目标。

// AlphaSwap

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);
    }
}

// SwapFirst

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);
        }
    }
}

// swapLast

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);

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

使用两个线程交换

1 个答案: