线程按指定顺序输出字符到数组的实例代码

下面是一个使用Java语言实现的线程按指定顺序输出字符到数组的实例代码。在这个例子中，我们创建了两个线程，分别负责向数组中添加字符，并确保它们按照指定的顺序执行。我们将使用`ReentrantLock`和`Condition`来实现线程间的顺序控制。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class OrderedCharArrayFiller {

    private char[] array;
    private int index = 0;
    private final int size;
    private final Lock lock = new ReentrantLock();
    private final Condition canWriteA = lock.newCondition();
    private final Condition canWriteB = lock.newCondition();
    private boolean isThreadA = true; // 控制哪个线程应该写入

    public OrderedCharArrayFiller(int size) {
        this.size = size;
        this.array = new char[size];
    }

    // 线程A的写入方法
    public void fillByA(char c) throws InterruptedException {
        lock.lock();
        try {
            while (!isThreadA) {
                canWriteA.await(); // 等待轮到A线程写入
            }
            if (index < size) {
                array[index++] = c;
                isThreadA = false; // 切换到B线程
                canWriteB.signal(); // 通知B线程可以写入
            }
        } finally {
            lock.unlock();
        }
    }

    // 线程B的写入方法
    public void fillByB(char c) throws InterruptedException {
        lock.lock();
        try {
            while (isThreadA) {
                canWriteB.await(); // 等待轮到B线程写入
            }
            if (index < size) {
                array[index++] = c;
                isThreadA = true; // 切换回A线程
                canWriteA.signal(); // 通知A线程可以写入
            }
        } finally {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        OrderedCharArrayFiller filler = new OrderedCharArrayFiller(10);

        Thread t1 = new Thread(() -> {
            try {
                for (char c = 'A'; c <= 'J'; c++) {
                    filler.fillByA(c);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        Thread t2 = new Thread(() -> {
            try {
                for (char c = 'a'; c <= 'j'; c++) {
                    filler.fillByB(c);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        t1.start();
        t2.start();

        try {
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        // 打印结果
        for (char c : filler.array) {
            System.out.print(c);
        }
    }
}

在这个例子中，我们创建了一个`OrderedCharArrayFiller`类，它包含一个字符数组和两个线程用于交替填充该数组。通过`ReentrantLock`和`Condition`，我们能够控制两个线程按照A、B的顺序交替写入字符。在`main`方法中，我们启动了两个线程，分别使用`fillByA`和`fillByB`方法填充数组，并在两个线程完成后打印数组内容。