JAVA 老掉牙的面试问题线程交替打印问题，分析实操一下

待我称王封你为后i 2023-09-23 23:32 37阅读 0赞

# 前言 #

新的一年了，首先是祝大家新年新气象，工作顺利，生活美满 。

万物复苏的一年， 大家都蠢蠢欲动！

### 金三银四快来了， 机会多不多？ ###

**‘’满大街机会‘’**

![dff1cead140348ff816e9a6f9d557777.png][]

好了不啰嗦，最近有比较多的小伙伴问这个线程交替打印的问题，我就来搞一搞。

# 正文 #

一个老掉牙的java面试问题 ， 多线程交替打印。

有打印 ABC 的， 有打印 123 的， 有打印到100的 。

其实都一样。

*ps： 最近好多小伙伴问这个，这个题这么热门么？*

**实例实战思路：**

拿一个来做示例， 就交替打印ABC. (文末也说下从1到100的)

一起看看这个小题目 ：

**主角**

>   
> 三个线程 线程A 线程 B 线程 C

**要做的事**

> 交替打印 A B C
> 
> 那就是 线程A 负责打印 A ，线程 B 负责打印 B ，线程C 负责打印 C 。

**简单分析：**

>   
> A线程打印完， B线程 打印 ；
> 
> B线程打印完 ，C 线程打印。
> 
>   
> 也就是说，这3个线程 ABC ，有顺序/协作 。
> 
> 那么这三个家伙 怎么知道自己要打印东西呢？
> 
>   
> 那必然是通知 和 等待 。

**思路：**

>   
> 三个线程都 准备就绪， 准备大展身手。
> 
>   
> 接到携带暗号的通知（默认暗号为 A） -> 核对通知的暗号 -> 打印->然后修改暗号-> 发出携带暗号通知（让别的线程认领）
> 
>   
> 如果接到通知，发现暗号不对，怎么办呢？ 继续进入等待，等待下个通知的到来。

**简图：**

![f705fd25caa34b92bb14a22d656146dc.png][]

三个线程的一举一动 ：

![89aada749060481180c612f9c195828d.png][]

![0358855583d34199b3b61f428a209cb2.png][]

ps:

如果是线程A打印完，就把通知暗号改成B，并发出通知；

如果是线程B打印完，就把通知暗号改成C，并发出通知；

同样，如果是线程C打印完，就把通知改回A，继续发通知。

代码 :

写个ReentrantLock条件控制来搞一下。

import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    import java.util.concurrent.locks.Condition;
    
    
    public class DoTest {
    
        //控制三个线程 ABC，保证同一时刻只有一个线程工作
        private static Lock lock = new ReentrantLock(true);
        
        //  Condition ,控制等待或是 通知
        private static Condition conditionA = lock.newCondition();
        private static Condition conditionB = lock.newCondition();
        private static Condition conditionC = lock.newCondition();
    
        //默认的通知 暗号 A
        private static String  CODE= "A";
    
    
        public static void main(String[] args) {
    
            Thread A = new Thread(() -> {
                while (true) {
                    try {
                        printA();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            Thread B = new Thread(() -> {
                while (true) {
                    try {
                        printB();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            Thread C = new Thread(() -> {
                while (true) {
                    try {
                        printC();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
            
            A.start();
            B.start();
            C.start();
        }
    
        public static void printA() throws InterruptedException {
    
            //等待
            lock.lock();
            try {
                //核对
                while (!CODE.equals("A")) {
                    //暗号不对，就进入等待
                    conditionA.await();
                }
                System.out.println("A");
                //改暗号，通知B
                CODE = "B";
                conditionB.signalAll();
            } finally {
                lock.unlock();
            }
        }
    
        public static void printB() throws InterruptedException {
            lock.lock();
            try {
                while (!CODE.equals("B")) {
                    conditionB.await();
                }
                System.out.println("B");
                //改暗号，通知C
                CODE = "C";
                conditionC.signalAll();
            } finally {
                lock.unlock();
            }
    
        }
    
        public static void printC() throws InterruptedException {
            lock.lock();
            try {
                while (!CODE.equals("C")) {
                    conditionC.await();
                }
                System.out.println("C");
                
                //改暗号，通知A
                CODE = "A";
                conditionA.signalAll();
            } finally {
                lock.unlock();
            }
    
        }
    
    
    }

效果：

![e1e4537144944e49b9132dbc90bc97ea.png][]

可以看到，三个线程 ABC 都开始 无休止的进行了 等待 -接通知 -核对- 打印-改暗号发通知 。

当然如果需要他们不这么无休止，只需要 做一个标识进行判断就好，例如 加在一起已经打印够100次了，就停止 之类的限制值。

举例， 如果交替打印，到100 就停止， 也就是

从1~100 线程A ，线程B ，线程 B 交替打印。

ok,代码稍作调整 ：

加上2个值

一个是打印的数字，这个会一直 +1 输出；

一个是用于线程循环的，之前是while(true) ,这样会一直跑。

![a7b65659b2ac45f59e5ccbbbe8702a61.png][]

如果 终止标记还是false，就继续执行:

![ac5833aa898341a79e05b85261c600d4.png][]

每个打印方法都加上判断和累计+1的代码：

![17a56cd212fb47ed9d39dc1211769b9b.png][]

看看效果：  
![d492cd5bbd4f4f419f9a2984117ea15e.png][]

整体代码贴一下：

import java.util.concurrent.locks.Lock;
    import java.util.concurrent.locks.ReentrantLock;
    import java.util.concurrent.locks.Condition;
    
    
    public class DoTest {
    
        //控制三个线程 ABC，保证同一时刻只有一个线程工作
        private static Lock lock = new ReentrantLock(true);
    
        //  Condition ,控制等待或是 通知
        private static Condition conditionA = lock.newCondition();
        private static Condition conditionB = lock.newCondition();
        private static Condition conditionC = lock.newCondition();
    
        //默认的通知 暗号 A
        private static String CODE = "A";
    
        //设置初始打印值
        private static int COUNT_NUM = 1;
    
        //线程是否需要终止 标记
        private static volatile boolean IS_INTERRUPT = false;
    
        public static void main(String[] args) {
    
            Thread A = new Thread(() -> {
                while (!IS_INTERRUPT) {
                    try {
                        printA();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            Thread B = new Thread(() -> {
                while (!IS_INTERRUPT) {
                    try {
                        printB();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            Thread C = new Thread(() -> {
                while (!IS_INTERRUPT) {
                    try {
                        printC();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
    
            A.start();
            B.start();
            C.start();
        }
    
        public static void printA() throws InterruptedException {
    
            //等待
            lock.lock();
            try {
                if (COUNT_NUM >= 100) {
                    IS_INTERRUPT = true;
                    return;
                }
                //核对
                while (!CODE.equals("A")) {
                    //暗号不对，就进入等待
                    conditionA.await();
                }
                System.out.println("A, count" + COUNT_NUM);
                //改暗号，通知B
                CODE = "B";
                COUNT_NUM = COUNT_NUM + 1;
                conditionB.signalAll();
            } finally {
                lock.unlock();
            }
        }
    
        public static void printB() throws InterruptedException {
            lock.lock();
            try {
    
                if (COUNT_NUM >= 100) {
                    IS_INTERRUPT = true;
                    return;
                }
    
                while (!CODE.equals("B")) {
                    conditionB.await();
                }
    
                System.out.println("B, count" + COUNT_NUM);
                //改暗号，通知C
                CODE = "C";
                COUNT_NUM = COUNT_NUM + 1;
    
                conditionC.signalAll();
            } finally {
                lock.unlock();
            }
    
        }
    
        public static void printC() throws InterruptedException {
            lock.lock();
            try {
    
                if (COUNT_NUM >= 100) {
                    IS_INTERRUPT = true;
                    return;
                }
    
                while (!CODE.equals("C")) {
                    conditionC.await();
                }
    
                System.out.println("C, count" + COUNT_NUM);
                //改暗号，通知A
                CODE = "A";
                COUNT_NUM = COUNT_NUM + 1;
                conditionA.signalAll();
            } finally {
                lock.unlock();
            }
    
        }
    
    
    }

可能看到这里，有些初学者会心有疑惑，因为他没了解过 ReentrantLock、Lock 、Condition ，就觉得这个看了不踏实。

没事的，其实只是为了给大家实打实分析思路， 用synchronized 配合 wait() 和 notifyAll 也是一样的。

notifyAll 大不了就全部通知唤醒，然后自己核对暗号再进入等待。

示例，上代码：

public class DoTest1 {
        private volatile int COUNT_NUM = 1;
        private volatile String CODE = "A";
        private static int oneTimes = 34;
        private static int othersTimes = 33;
    
        void onePrint() {
            synchronized (this) {
                while(!CODE.equals("A")) {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + ": " + COUNT_NUM);
                COUNT_NUM++;
                CODE = "B";
                notifyAll();
            }
        }
        void twoPrint() {
            synchronized (this) {
                while(!CODE.equals("B")) {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + ": " + COUNT_NUM);
                COUNT_NUM++;
                CODE = "C";
                notifyAll();
            }
        }
        void threePrint() {
            synchronized (this) {
                while(!CODE.equals("C")) {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println(Thread.currentThread().getName() + ": " + COUNT_NUM);
                COUNT_NUM++;
                CODE = "A";
                notifyAll();
            }
        }
    
    
        public static void main(String[] args) {
            DoTest1 printNumber = new DoTest1();
            new Thread(() -> {
                for (int i = 0; i < oneTimes; i++) {
                    printNumber.onePrint();
                }
            },"线程A").start();
    
            new Thread(() -> {
                for (int i = 0; i < othersTimes; i++) {
                    printNumber.twoPrint();
                }
            },"线程B").start();
    
            new Thread(() -> {
                for (int i = 0; i < othersTimes; i++) {
                    printNumber.threePrint();
                }
            },"线程C").start();
        }
    }

代码简析：  
![19c24541932d49599ea2ff1d9e1d5c6b.png][]

看看效果:

![4b11b4f68be24a988a7fd7fbfa0a7408.png][]

好了，该篇就到这吧。

[dff1cead140348ff816e9a6f9d557777.png]: https://img-blog.csdnimg.cn/dff1cead140348ff816e9a6f9d557777.png
[f705fd25caa34b92bb14a22d656146dc.png]: https://img-blog.csdnimg.cn/f705fd25caa34b92bb14a22d656146dc.png
[89aada749060481180c612f9c195828d.png]: https://img-blog.csdnimg.cn/89aada749060481180c612f9c195828d.png
[0358855583d34199b3b61f428a209cb2.png]: https://img-blog.csdnimg.cn/0358855583d34199b3b61f428a209cb2.png
[e1e4537144944e49b9132dbc90bc97ea.png]: https://img-blog.csdnimg.cn/e1e4537144944e49b9132dbc90bc97ea.png
[a7b65659b2ac45f59e5ccbbbe8702a61.png]: https://img-blog.csdnimg.cn/a7b65659b2ac45f59e5ccbbbe8702a61.png
[ac5833aa898341a79e05b85261c600d4.png]: https://img-blog.csdnimg.cn/ac5833aa898341a79e05b85261c600d4.png
[17a56cd212fb47ed9d39dc1211769b9b.png]: https://img-blog.csdnimg.cn/17a56cd212fb47ed9d39dc1211769b9b.png
[d492cd5bbd4f4f419f9a2984117ea15e.png]: https://img-blog.csdnimg.cn/d492cd5bbd4f4f419f9a2984117ea15e.png
[19c24541932d49599ea2ff1d9e1d5c6b.png]: https://img-blog.csdnimg.cn/19c24541932d49599ea2ff1d9e1d5c6b.png
[4b11b4f68be24a988a7fd7fbfa0a7408.png]: https://img-blog.csdnimg.cn/4b11b4f68be24a988a7fd7fbfa0a7408.png