如何在Java中使N个线程以循环的方式轮换？

我最近讨论了关于Stackoverflow的这个问题，其中的问题是在两个线程中打印偶数和奇数，以这样一种方式，它们以增量顺序打印。问题是，我在哪里提供了一个解决方案。这让我想到，如果我们需要N个线程以循环的方式，以预定义的顺序轮流，我们应该怎么做？我试着用CyclicBarrier来做这个。这是我的代码：

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;

public class NThreadTurnTaking {

public static void main(String[] args) {
    NThreadTurnTaking nThreadTurnTaking =  new NThreadTurnTaking();
    CyclicBarrier cyclicBarrier =  new CyclicBarrier(3);
    NThreadTurnTaking.A  a = nThreadTurnTaking.new A(cyclicBarrier);
    NThreadTurnTaking.B  b = nThreadTurnTaking.new B(cyclicBarrier);
    NThreadTurnTaking.C  c = nThreadTurnTaking.new C(cyclicBarrier);
    Thread t1  =  new Thread(a);
    Thread t2  =  new Thread(b);
    Thread t3  =  new Thread(c);
    t1.start();
    t2.start();
    t3.start();     
}

class A implements Runnable{
    private final CyclicBarrier cyclicBarrier;

    public A(CyclicBarrier cyclicBarrier) {
        super();
        this.cyclicBarrier = cyclicBarrier;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("A");
            try {
                cyclicBarrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }

    }
}
class B implements Runnable{
    private final CyclicBarrier cyclicBarrier;

    public B(CyclicBarrier cyclicBarrier) {
        super();
        this.cyclicBarrier = cyclicBarrier;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("B");
            try {
                cyclicBarrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }
}
class C implements Runnable{
    private final CyclicBarrier cyclicBarrier;

    public C(CyclicBarrier cyclicBarrier) {
        super();
        this.cyclicBarrier = cyclicBarrier;
    }
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("C");
            try {
                cyclicBarrier.await();
            } catch (InterruptedException | BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }
}
}

import java.util.concurrent.BrokenBarrierException；
导入java.util.concurrent.CyclicBarrier；
公共课收费{
公共静态void main（字符串[]args）{
NThreadTurnTaking NThreadTurnTaking=新的NThreadTurnTaking（）；
CyclicBarrier CyclicBarrier=新的CyclicBarrier（3）；
NThreadTurnTaking.A A=NThreadTurnTaking.new A（自行车承运人）；
NThreadTurnTaking.B B=NThreadTurnTaking.new B（自行车承运人）；
NThreadTurnTaking.C=NThreadTurnTaking.new C（cyclicBarrier）；
螺纹t1=新螺纹（a）；
螺纹t2=新螺纹（b）；
螺纹t3=新螺纹（c）；
t1.start（）；
t2.start（）；
t3.start（）；
}
类实现可运行的{
私人决赛自行车手自行车手；
公共A（骑自行车的人骑自行车的人）{
超级（）；
this.cyclicBarrier=cyclicBarrier；
}
@凌驾
公开募捐{
对于（int i=0；i<10；i++）{
系统输出打印项次（“A”）；
试一试{
cyclicBarrier.await（）；
}catch（中断异常|断开异常）{
e、 printStackTrace（）；
}
}
}
}
类实现可运行的{
私人决赛自行车手自行车手；
公共B（骑自行车的人骑自行车的人）{
超级（）；
this.cyclicBarrier=cyclicBarrier；
}
@凌驾
公开募捐{
对于（int i=0；i<10；i++）{
系统输出打印项次（“B”）；
试一试{
cyclicBarrier.await（）；
}catch（中断异常|断开异常）{
e、 printStackTrace（）；
}
}
}
}
类C实现可运行的{
私人决赛自行车手自行车手；
公共C（骑自行车的人骑自行车的人）{
超级（）；
this.cyclicBarrier=cyclicBarrier；
}
@凌驾
公开募捐{
对于（int i=0；i<10；i++）{
系统输出打印项次（“C”）；
试一试{
cyclicBarrier.await（）；
}catch（中断异常|断开异常）{
e、 printStackTrace（）；
}
}
}
}
}

我希望我的程序按顺序打印A->B->C。虽然使用CyclicBarrier确实可以确保它们一个接一个地打印，但顺序没有得到维护，这是显而易见的，因为我没有做任何特别的事情来告诉我的程序我想要一个特定的顺序。这是输出：

B C A. A. C B B A. C

---

那么，我们如何确保这里的秩序呢？请提供帮助。

如果任务需要一个接一个地执行，解决方案是在一个线程上执行它们。那么提供订单就很简单了。奇偶作业只是为了学习一些线程技术。在我看来，这个要求没有现实意义。如果一个结果向量需要有一个顺序，人们可能会首先收集所有结果，然后对它们进行排序（或者将它们添加到排序数据结构中）。@Fildor感谢您的澄清