Java多线程顺序打印ABC的3种实现方案对比

1. 多线程顺序打印ABC的核心挑战

当我们需要三个线程严格按照ABC的顺序循环打印时，表面看起来简单的需求背后隐藏着几个关键的技术难点。首先，线程的执行顺序是不确定的，操作系统会根据调度算法随机分配CPU时间片。其次，线程间的同步机制如果设计不当，很容易出现死锁或饥饿现象。

我在实际项目中遇到过类似需求，当时是为一个工业控制系统设计状态指示灯模块。三个不同颜色的LED需要按特定顺序闪烁，而每个LED由一个独立线程控制。最初尝试用简单的sleep延时，结果发现随着系统负载变化，闪烁顺序会完全乱套。

2. 基于锁机制的实现方案

2.1 同步锁的基本原理

最直接的解决方案是使用对象锁配合wait/notify机制。我们创建三个线程和一个共享锁对象，通过wait()让线程等待，notifyAll()唤醒其他线程。关键点在于：

java复制class PrintABC {
    private int state = 0; // 0:A, 1:B, 2:C
    private final Object lock = new Object();
    
    public void printA() throws InterruptedException {
        synchronized (lock) {
            while (state != 0) {
                lock.wait();
            }
            System.out.print("A");
            state = 1;
            lock.notifyAll();
        }
    }
    // 类似实现printB和printC
}

2.2 完整实现代码

以下是完整的10次循环打印实现：

java复制public class SequentialPrint {
    private static final int MAX_COUNT = 10;
    private static int state = 0;
    private static final Object lock = new Object();

    static class PrintA implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < MAX_COUNT; ) {
                synchronized (lock) {
                    while (state % 3 != 0) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            Thread.currentThread().interrupt();
                        }
                    }
                    System.out.print("A");
                    state++;
                    i++;
                    lock.notifyAll();
                }
            }
        }
    }
    
    // PrintB和PrintC类似，只需修改判断条件和打印字符
}

关键提示：必须使用while循环而不是if判断状态，因为可能存在虚假唤醒(spurious wakeup)的情况。这是Java线程规范明确指出的注意事项。

3. 使用条件变量的精准控制方案

3.1 ReentrantLock与Condition的优势

相比synchronized，ReentrantLock配合Condition可以实现更精细的线程控制。每个线程有自己的Condition，避免不必要的唤醒：

java复制class PrintABCWithCondition {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition conditionA = lock.newCondition();
    private final Condition conditionB = lock.newCondition();
    private final Condition conditionC = lock.newCondition();
    private int state = 0;
    
    public void printA() throws InterruptedException {
        lock.lock();
        try {
            while (state % 3 != 0) {
                conditionA.await();
            }
            System.out.print("A");
            state++;
            conditionB.signal();
        } finally {
            lock.unlock();
        }
    }
    // 类似实现B和C
}

3.2 性能对比测试

在实际压力测试中（循环100万次），两种方案的性能表现：

条件变量方案在长时间运行和高并发场景下表现更优，特别是在线程数量增加时。

4. 信号量(Semaphore)的优雅实现

4.1 信号量工作原理

信号量通过许可证控制访问，非常适合这种顺序控制的场景。我们为每个线程分配一个信号量：

java复制public class SemaphoreSolution {
    private static Semaphore semA = new Semaphore(1);
    private static Semaphore semB = new Semaphore(0);
    private static Semaphore semC = new Semaphore(0);
    
    static class ThreadA implements Runnable {
        public void run() {
            try {
                for (int i = 0; i < 10; i++) {
                    semA.acquire();
                    System.out.print("A");
                    semB.release();
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }
    }
    // ThreadB和ThreadC类似
}

4.2 信号量方案的优势

1. 代码更简洁直观，每个线程只关心自己的信号量
2. 没有共享的状态变量，减少竞态条件风险
3. 容易扩展到更多线程的场景
4. 支持超时和中断处理

5. 生产环境中的注意事项

5.1 线程池的正确使用

在实际项目中，直接创建线程不是最佳实践。应该使用线程池管理：

java复制ExecutorService executor = Executors.newFixedThreadPool(3);
executor.submit(new ThreadA());
executor.submit(new ThreadB());
executor.submit(new ThreadC());
executor.shutdown();

重要经验：线程池大小应根据实际需求设置，过大会导致资源浪费，过小可能引起性能问题。对于I/O密集型任务，建议线程数 = CPU核数 * (1 + 平均等待时间/平均计算时间)

5.2 异常处理与资源释放

必须妥善处理InterruptedException，确保线程能正确退出：

java复制try {
    while (!Thread.currentThread().isInterrupted()) {
        // 业务逻辑
    }
} catch (InterruptedException e) {
    Thread.currentThread().interrupt();
    // 清理资源
} finally {
    lock.unlock(); // 确保锁被释放
}

5.3 性能优化技巧

1. 避免锁粗化：同步块应尽可能小
2. 减少上下文切换：适当调整线程优先级
3. 使用ThreadLocal存储线程私有数据
4. 考虑使用无锁数据结构如AtomicInteger

6. 扩展应用场景

这种线程顺序控制模式在以下场景非常有用：

1. 流水线作业系统：每个线程处理一个工序
2. 游戏开发：角色动作的序列化执行
3. 物联网设备：传感器数据的顺序采集
4. 金融交易：订单处理的状态机转换

我曾经在一个电商促销系统中应用类似技术，确保库存检查→订单创建→支付处理的严格顺序，避免了超卖问题。关键是在高并发下仍能保持顺序性，这比简单的同步锁要可靠得多。