面试题：多线程按顺序输出

最近遇到一个题目：编写一个程序，开启 3 个线程，这三个线程的 ID 分别为 A、B、C，每个线程将自己的 ID 在屏幕上打印 10 遍，要求输出的结果必须按顺序显示。如：ABCABCABC……

当时很懵逼，不知道咋解，看来还是对线程和锁的理解不是很深刻。

public class MultiLockDemo {
    /**
     * 使用公平锁，防止一个线程连续获取锁的情况
     */
    private Lock lock = new ReentrantLock(true);
    // 计数
    private int COUNT = 0;
    // 循环次数
    private int LOOP_NUM = 10;
    // 计数取模
    private int MOD = 3;

    private void printChar(int threadIdentify) {
        for (int i = 0; i < LOOP_NUM; ) {
            lock.lock();
            try {
                /**
                 * threadIdentify: 0 表示线程 a, 1 表示线程 b, 2 表示线程 c
                 */
                if (COUNT % MOD == threadIdentify) {
                    System.out.print(Thread.currentThread().getName());
                    COUNT++;
                    i++;
                }
            } finally {
                lock.unlock();
            }
        }
    }

    public static void main(String[] args) {
        MultiLockDemo lockDemo = new MultiLockDemo();
        Thread a = new Thread(() -> lockDemo.printChar(0), "A");
        Thread b = new Thread(() -> lockDemo.printChar(1), "B");
        Thread c = new Thread(() -> lockDemo.printChar(2), "C");

        a.start();
        b.start();
        c.start();
    }
}

上面这个版本存在线程空跑 for 循环占用 CPU 的情况，通过线程的等待通知机制优化成如下版本（可参考：聊聊高并发（十四）理解Java中的管程，条件队列，Condition以及实现一个阻塞队列）：

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

public class MultiLockDemo {
    /**
     * 使用公平锁，防止一个线程连续获取锁的情况
     */
    private Lock lock = new ReentrantLock();
    // 计数
    private int COUNT = 0;

    // 管程模型中的条件变量  
    private Condition isTarget = lock.newCondition();

    private void printChar(int threadIdentify) {
        for (int i = 0; i < 10; i++) {
            lock.lock();
            try {
                /**
                 * threadIdentify: 0 表示线程 a, 1 表示线程 b, 2 表示线程 c
                 */
                while (COUNT % 3 != threadIdentify) {
                    try {
                        // 调用 await 之后会释放锁资源，让出 CPU 时间片
                        isTarget.await();
                        // 这里即使唤醒之后会有多个线程，都需要到管程入口队列中获取对应的锁才能继续往下执行，
                        // 只是这里的执行点不是 printChar 方法的入口，而是执行 await() 之后的代码 
                        // 管程是一个解决并发问题的模型，对管程有疑问的话，可以去网上搜索资料
                        // 加锁的这段临界区代码永远只有一个线程可以访问

                        // 线程被唤醒以后继续在此处往下执行，所以这个地方用 while 循环，
                        // 防止 COUNT % 3 != threadIdentify 这个条件不满足了
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.print(Thread.currentThread().getName());
                COUNT++;
                
                // 这里通知完，仅是从管程的「条件等待队列」中进入到「入口等待队列」去重新获取到锁资源然后继续执行，
                // 这也是  while (COUNT % 3 != threadIdentify) 这里为什么用 while 循环的根本原因。
                // 当被唤醒的线程在「入口等待队列」获取锁然后执行 await() 后面的代码时，有可能曾经满足的条件，
                // 此刻已经不满足了，所以需要循环方式检验条件变量
                isTarget.signalAll();
            } finally {
                lock.unlock();
            }
            System.out.print(i);
        }
    }

    public static void main(String[] args) {
        MultiLockDemo lockDemo = new MultiLockDemo();
        Thread a = new Thread(() -> lockDemo.printChar(0), "A");
        Thread b = new Thread(() -> lockDemo.printChar(1), "B");
        Thread c = new Thread(() -> lockDemo.printChar(2), "C");

        c.start();
        b.start();
        a.start();
    }
}

参考：java多线程顺序执行并顺序输出ABC问题
一道面试题：多个线程按顺序输出