给你三个线程，如何让它们交替打印1、2、3

问题提出

前几天写了一篇 Java多线程：写一下两个线程交替打印 0~100 的奇偶数 介绍了如果用 wait/notify 控制两个线程交替执行，最后留了一个扩展问题：有三个线程，要求让它们交替输出 1、2、3，打印内容如下：

线程1：1
线程2：2
线程3：3
线程1：1
线程2：2
线程3：3
……

该如何实现？

分析

沿用两个线程的交替打印的思路，重点是当第一个线程获取到锁的时候第二个线程在wait状态等待被唤醒，此时第一个线程完成任务时，主动唤醒第二个线程，自己进入等待状态，不与之竞争。这样就能起到“我做完轮到你，你做完轮到我”的状态。

而三个线程的情况下是无法简单通过一个锁来完成的，因为当多个线程在等待时，我们无法通过 notify 来唤醒指定的线程。如何解决呢？

解决

我们可以使用三个锁 lock1、lock2 和 lock3，分别对应要执行的三个线程 t1、t2 和 t3。

当前线程t1执行时，先锁定下一个线程t2对应的锁 lock2，然后再获取自己线程对应的锁 lock1，当两个锁都拿到时才打印，并唤醒在等待 lock1 的线程t3，退出 lock1 的同步代码块，释放 lock1，此时 t3 拿到 lock1，等待获取 lock3（lock3 在启动时就被 t2 占了）。之后释放 lock2 让 t2 进入执行状态自己进入等待 lock2 被唤醒，此时线程进行等待状态，以免进入下一次循环与 t2 竞争 lock2。

t2 也是相同的逻辑，唤醒等待 lock2 的 t1，此时 t1 才从上次循环中退出再次获取 lock2，然后释放 lock3, 让 t3 进入执行状态。

最终的目的就是要实现三个线程相互等待前面两个线程执行完，形成一个循环。

private int count = 0;
private final Object lock1 = new Object();
private final Object lock2 = new Object();
private final Object lock3 = new Object();

public static void main(String[] args) throws InterruptedException {
    new MultiTurningThread().multiTurning();
}

public void multiTurning() throws InterruptedException {
    Thread t1 = new Thread(() -> {
        while (count <= 100) {
            synchronized (lock2) {
                synchronized (lock1) {
                    System.out.println("线程1: 1");
                    count++;
                    // 唤醒正等待 lock1 的 t3
                    lock1.notifyAll();
                }
                try {
                    // 如果还需要继续执行，则让出 lock2 让 t2 执行，自己进入等待状态
                    if (count <= 100) {
                        lock2.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    });
    Thread t2 = new Thread(() -> {
        while (count <= 100) {
            synchronized (lock3) {
                synchronized (lock2) {
                    System.out.println("线程2: 2");
                    count++;
                    // 唤醒正在等待 lock2 的 t1
                    lock2.notifyAll();
                }
                try {
                    // 如果还需要继续执行，则让出 lock3 让 t3 执行，自己进入等待状态
                    if (count <= 100) {
                        lock3.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    });
    Thread t3 = new Thread(() -> {
        while (count <= 100) {
            synchronized (lock1) {
                synchronized (lock3) {
                    System.out.println("线程3: 3");
                    count++;
                    // 唤醒正在等待 lock3 的 t2
                    lock3.notifyAll();
                }
                try {
                    // 如果还需要继续执行，则让出 lock1 让 t1 执行，自己进入等待状态
                    if (count <= 100) {
                        lock1.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    });
    t1.start();
    t2.start();
    t3.start();
}

三个线程的执行逻辑都是一样的，因此可以抽取成实现 Runnable 的对象:

 private int count = 0;
private final Object lock1 = new Object();
private final Object lock2 = new Object();
private final Object lock3 = new Object();

public static void main(String[] args) throws InterruptedException {
    new MultiTurningThread().multiTurning();
}

public void multiTurning() throws InterruptedException {
    Thread t1 = new Thread(new MultiTurningRunner(lock2, lock1, "线程1: 1"));
    Thread t2 = new Thread(new MultiTurningRunner(lock3, lock2, "线程2: 2"));
    Thread t3 = new Thread(new MultiTurningRunner(lock1, lock3, "线程3: 3"));
    t1.start();
    t2.start();
    t3.start();
}

class MultiTurningRunner implements Runnable {
    private final Object nextLock;
    private final Object currentLock;
    private final String content;

    public MultiTurningRunner(Object nextLock, Object currentLock, String content) {
        this.nextLock = nextLock;
        this.currentLock = currentLock;
        this.content = content;
    }

    @Override
    public void run() {
        while (count <= 100) {
            synchronized (nextLock) {
                synchronized (currentLock) {
                    System.out.println(content);
                    count++;
                    // 唤醒等待当前锁的线程
                    currentLock.notifyAll();
                }
                try {
                    // 如果还需要继续执行，则让出下一个线程对应的锁并进入等待状态
                    if (count <= 100) {
                        nextLock.wait();
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

执行结果：

线程1: 1
线程2: 2
线程3: 3
线程1: 1
线程2: 2
线程3: 3
……

参考文章：

• 多线程交替打印ABC的多种实现方法