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

最新推荐文章于 2025-12-28 23:02:17 发布
转载 最新推荐文章于 2025-12-28 23:02:17 发布 · 133 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：https://mp.weixin.qq.com/s?__biz=MzUzMTA2NTU2Ng==&mid=2247569810&idx=2&sn=576a9d7eaa43b4719bbf4a035d01ea6e&chksm=fa4bae23cd3c2735369cb24796013d54519926dac125545253e0e49be8f748347983f62e3399&scene=126&sessionid=0
文章标签：

#java #面试 #开发语言 #职场和发展

点击上方“芋道源码”，选择“设为星标”

管她前浪，还是后浪？

能浪的浪，才是好浪！

每天 10:33 更新文章，每天掉亿点点头发...

源码精品专栏

 

来源：blog.youkuaiyun.com/qq_35387940/

article/details/128828799

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

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

其实都一样。

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

实例实战思路

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

一起看看这个小题目 ：

基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址：https://github.com/YunaiV/ruoyi-vue-pro

  • 视频教程：https://doc.iocoder.cn/video/

主角

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

基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能

  • 项目地址：https://github.com/YunaiV/yudao-cloud

  • 视频教程：https://doc.iocoder.cn/video/

要做的事

交替打印  A B C

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

简单分析

A线程打印完， B线程 打印 ；

B线程打印完 ，C 线程打印。

也就是说，这3个线程 ABC ，有顺序/协作 。

那么这三个家伙 怎么知道自己要打印东西呢？

那必然是通知 和 等待 。

思路

三个线程都 准备就绪， 准备大展身手。

接到携带暗号的通知（默认暗号为 A） -> 核对通知的暗号 -> 打印->然后修改暗号-> 发出携带暗号通知（让别的线程认领）

如果接到通知，发现暗号不对，怎么办呢？ 继续进入等待，等待下个通知的到来。

简图

5e3807d01155b5aad54e3a16d9fa9eb4.png

三个线程的一举一动 ：

5848fce69f9331ee11f76ecb28e6b578.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();
        }
 
    }
 
 
}

效果：

9465412c8c3ce0c6253f12d2931f753a.png

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

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

举例， 如果交替打印，到100 就停止， 也就是 从1~100  线程A ，线程B ，线程 B 交替打印。

ok，代码稍作调整 ：

加上2个值

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

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

8180282fd89bf76776cf21c9e30b5015.png

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

539ba371830d293ba0c4791dad42402c.png

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

9eb07b063ff15f4761cb9417be040dfe.png

看看效果：

66f209285a0a9493979b3eb3e4fdf005.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();
    }
}

代码简析：

d4823fb469a22972d333afd3dccd2ca5.png

看看效果:

f84c79329975c3c4d102dbda8bd7a2ea.png

好了，该篇就到这吧。

欢迎加入我的知识星球，一起探讨架构，交流源码。加入方式，长按下方二维码噢：

51a8477db1eca5f9f7ff86de66aa121f.png

已在知识星球更新源码解析如下：

00f937955983720036aabba74af01584.jpeg

cce83f34189f619f1941be89bcf2cc8d.jpeg

4a177cbb4114767014f6ae8eee865fb0.jpeg

f5fff3df8193909d7fa07e5a0235c86e.jpeg

最近更新《芋道 SpringBoot 2.X 入门》系列，已经 101 余篇，覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。

提供近 3W 行代码的 SpringBoot 示例，以及超 4W 行代码的电商微服务项目。

获取方式：点“在看”，关注公众号并回复 666 领取，更多内容陆续奉上。

文章有帮助的话，在看，转发吧。
谢谢支持哟 (*^__^*）
Java老掉牙的面试问题：线程交替打印问题，分析实操一下！
m0_71777195的博客
03-25 237
接到携带暗号的通知（默认暗号为 A） -> 核对通知的暗号 -> 打印->然后修改暗号-> 发出携带暗号通知（让别的线程认领）当然如果需要他们不这么无休止，只需要 做一个标识进行判断就好，例如 加在一起已经打印够100次了，就停止 之类的限制值。那就是 线程A 负责打印 A ，线程 B 负责打印 B ，线程C 负责打印 C。有打印 ABC 的， 有打印 123 的， 有打印到100的。同样，如果是线程C打印完，就把通知改回A，继续发通知。举例， 如果交替打印，到100 就停止， 也就是。
Java社招面试题：MySQL存储引擎 MyISAM 与 InnoDB 区别？——小米的社招血泪记
孤芳不自赏
07-29 923
MyISAM和InnoDB的区别，可能是每一位Java程序员社招路上最容易忽略、却又最容易踩坑的问题。今天就听听小米是怎么因为这个问题差点在终面“翻车”的故事！
JAVA 老掉牙的面试问题 线程交替打印问题，分析实操一下
默默不代表沉默
02-01 4132
java 面试， 线程交替打印
Java后端真实面试题大全(有详细答案)--高频/真题
热门推荐
IT利刃出鞘的博客
11-24 16万+
本文分享Java后端真实高频面试题，有详细答案，保你稳过面试。题目包括：Java基础、多线程、JVM、数据库、Redis、Shiro、Spring、SpringBoot、MyBatis、MQ、ELK、SpringCloud、设计模式等。 本博客包含从简单到困难、从高频到低频的题目，适合所有Java求职者，包括：刚入门的、三年以内经验、三到五年经验、五到十年经验等。
Java开发大厂面试大揭秘：如何提高面试成功率？
2401_84585615的博客
05-31 747
今天我们分享了提高面试成功率的 N 个方法，它们主要分为三个维度：面试前分析、面试中展现和面试后复盘，如下图所示：祝愿每个看了本专栏的人都能获得自己心仪的 Offer。
Java面试题（高频、有答案，全网最强）
IT利刃出鞘的博客
11-07 1687
这是一套全网最强的Java面试题，吊打网上所有Java面试题。
使用Python求解最优化问题：从理论到实践的全方位指南
T20151470的博客
07-09 1356
最优化既是科学也是艺术。Python为我们提供了强大的工具集，但真正掌握优化需要深入理解问题本质和算法原理。随着量子优化、自动微分和强化学习等新技术的发展，优化领域正经历深刻变革。保持开放：拥抱新技术，如基于JAX的自动微分优化问题驱动：避免"锤子找钉子"，根据问题特性选择工具理解局限：认识NP难问题的计算复杂性，合理设置预期交叉融合：结合机器学习与优化技术解决复杂问题最优化之路无止境，Python作为载体，承载着人类对"最优解"的不懈追求。
Java开发，别再用老掉牙的SSH架构了
东南草堂
12-08 1384
虽然 SSH 框架过时，但它在 Java 开发历史中留下了不可磨灭的印记。在新项目中，它的劣势使得现代框架如 Spring Boot 和微服务架构成为主流。简单对比：对于新项目，建议直接使用现代框架，而对于维护旧系统，需要逐步迁移以适应当前的技术趋势。如果有更多具体需求，可以继续探讨细化方案！
多线程并发编程的基本问题
TCP/IP
10-03 5948
这是个老掉牙的话题，但基本上绝大多数的讨论都跑偏了。 绝大多数讨论的核心在于 如何设计一把锁来同步共享变量的访问。 这事实上完全是本末倒置： 我们需要设计的一个立交桥，而不是为了设计一个红绿灯！ 事实上，多线程编程就不应该访问共享变量，如果真的要在多线程访问共享变量，唯一高效的方案就是 严格控制时序。 嗯，先来后到是唯一的方法。至于说设计这样那样的锁，那完全是惰政，只是为了防止出问题而已。 早在100多年前，就可以在同一根电话线上传输不同的话路，这得益于严格的时隙分配和复用机制，后来时代进步了，事情反而
老掉牙的问题：二叉树的遍历
08-19
二叉树的三种遍历的递归和非递归方法，语言种类，C++，如果有不足的地方，请与作者联系，谢谢。
【java入门到放弃】网络
WZDBXHNL的博客
12-28 623
防火墙既可以是硬件，也可以是软件，本质上是一种，而不是只能对应某一种形态。
点赞系统问题
amdkk的博客
12-26 843
​​：Spring Pulsar 提供的接口，允许通过customize方法深度定制消费者行为。批量接收策略配置。：控制批量消息接收策略maxNumMessages：单次批量拉取多少条信息timeout：超时后触发批量处理。NACK重试策略当消费者调用时触发重试。：消息重投递的退避策略接口。.minDelayMs(1000) // 初始延迟 1 秒 .maxDelayMs(60000) // 最大延迟 60 秒 .multiplier(2) // 指数退避倍数。
计算机毕业设计|基于springboot + vue健康茶饮销售管理系统(源码+数据库+文档)
12-24 902
本文介绍了基于SpringBoot+Vue的健康茶饮销售管理系统开发。系统采用前后端分离架构，后端使用SpringBoot框架简化配置，前端采用Vue实现组件化开发，数据库选用MySQL。文章详细说明了系统设计原则、技术选型理由，并提供了代码示例和测试案例。系统功能完整，包含商品管理、用户认证等模块，通过严格测试确保安全性。文末附有源码获取方式和最新毕设选题推荐，适合作为计算机专业学生的项目参考。
抽象类和接口的区别
tryxr的博客
12-27 642
本文对比了Java中接口（Interface）与抽象类（AbstractClass）的8个核心区别。主要差异包括：抽象类使用abstract class定义，支持单继承，可包含实例字段和构造器，体现"is-a"关系；接口使用interface定义，允许多实现，仅包含常量，体现"can-do"能力。抽象类适合共享代码和状态，接口适合定义跨类能力。建议优先使用接口定义能力，仅在需要共享状态或实现模板方法时使用抽象类，并考虑组合优于继承。二者可结合使用，如Shape抽象类实
通过adb命令获取某个window或View/子View的绘制内容并输出为png图片的方法
Railshiqian的博客
12-23 1000
本文介绍了通过adb工具获取Android系统Window和View结构的方法。首先需要建立adb与ViewServer的连接（端口4939），然后通过"LIST"命令获取可dump的窗口列表，再使用"DUMP [窗口ID]"命令查看指定窗口的View树结构。该方法可帮助开发者分析应用界面问题，替代已废弃的Hierarchy View工具。示例展示了如何获取系统导航栏TopCarSystemBar的View层级信息，包括ViewGroup的各种属性和状态。
c#Socket学习，使用Socket创建一个在线聊天，日志笔记（5）
学不会shader
12-25 1034
32位整数：0x12345678高位字（High Word）：0x1234（高16位）低位字（Low Word）：0x5678（低16位）64位整数：0x123456789ABCDEF0高位双字（High Dword）：0x12345678（高32位）低位双字（Low Dword）：0x9ABCDEF0（低32位）
mybatis-plus插件解决sql报错：this is incompatible with sql_mode=only_full_group_by ”
吉他程序员的博客
12-23 284
解决的办法可以改sql，也可以改sql服务的conf配置， 但是如果你项目用的是mybatis-plus插件 ， 就可以用我介绍的很简单的方法。是 MySQL 的严格模式要求，确保 GROUP BY 查询的语义明确。这个错误是 MySQL 5.7+ 版本中最常见的兼容性问题之一。SELECT 列表中的列不在 GROUP BY 子句中。MySQL 无法确定从分组中的哪行返回这些列的值。且这些列也不是聚合函数的参数。然后重启项目就可以了。
blob是啥
最新发布
wniuniu_的博客
12-28 556
Onode: 代表一个 Ceph 对象（如Extent: 逻辑段，表示对象内某个偏移量（Offset）到长度（Length）的区间。Blob物理存储单元的抽象。它代表磁盘上的一组块，是 BlueStore 执行**压缩（Compression）和校验（Checksum）**的最小独立边界。简单类比：如果 Onode 是“一本书”，Extent 是“书页的页码”，那么Blob 就是“装订在一起的一叠纸”。这叠纸不仅存了文字（数据），边缘还盖了防伪印章（Checksum）。你说得对，
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值