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

news2024/11/23 7:55:51

前言

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

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

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

‘’满大街机会‘’


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

正文


一个老掉牙的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） -> 核对通知的暗号 -> 打印->然后修改暗号-> 发出携带暗号通知（让别的线程认领）


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

简图：

 三个线程的一举一动 ：

 

 

 

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

    }


}

效果：

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

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

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

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

ok,代码稍作调整 ：

加上2个值

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

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

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

 

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

 

 看看效果：

 整体代码贴一下：
 

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

代码简析：

 看看效果:

 

好了，该篇就到这吧。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/190612.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

开关电源-TL431与光耦组成的电压反馈电路-TL431工作过程分析

开关电源-TL431与光耦组成的电压反馈电路-TL431工作过程分析

开关电源&#xff1a;TL431与光耦组成的电压反馈电路 #开关电源#开关电源最基本的要求是输入电压变化时&#xff0c;输出电压保持恒定&#xff0c;而与此相关的测试如电压调整率、负载调整率等也是衡量开关电源性能的重要指标&#xff0c;实现输出电压恒定的方式是反馈&#x…
阅读更多...
【Catalyst 9000上EEM的部署方法和示例，你看明白了吗？】

【Catalyst 9000上EEM的部署方法和示例，你看明白了吗？】

新的一年 新的征程 新的课程开班 等你来学&#xff01; EEM&#xff08;Embedded Event Manager&#xff09;作为一个自动化的脚本部署在设备上&#xff0c;可以根据指定的trigger来自动完成提前布置的任务&#xff0c;如信息的收集或特定的操作。一个完整的EEM需要包含Na…
阅读更多...
Python学习-----起步2(变量与转义符)

Python学习-----起步2(变量与转义符)

目录 前言 Python变量/常量使用规则 基本数据变量类型 整形&#xff08;int&#xff09; 浮点型&#xff08;float&#xff09; 字符串类型&#xff08;str&#xff09; 布尔类型&#xff08;bool&#xff09; 转义符 习题 前言 在我们学习C语言时&#xff0c;我们学了很…
阅读更多...
对象之间的拷贝

对象之间的拷贝

这里写目录标题Lambda 的 builderidea 自动生成插件 GenerateAllSetterMapStructDozer在开发的时候经常会有业务代码之间有很多的 JavaBean 之间的相互转化&#xff0c;比如 PO/DTO/VO/QueryParam 之间的转换问题&#xff0c;本文总结一下各种转换方法Lambda 的 builder 使用构…
阅读更多...
有幸得到Alibaba内部Gradle实战笔记，趁机狂补

有幸得到Alibaba内部Gradle实战笔记，趁机狂补

虽然一直在接触 Gradle&#xff0c;但对 Gradle 始终都有一些陌生感&#xff0c;表现在日常的开发中就是不敢随便改 build.gradle 文件&#xff0c;一旦 sync 出错&#xff0c;只会复制错误找谷歌&#xff0c;可是解决方案也不一定能够完美解决自己的问题。还有就是不熟悉 Grad…
阅读更多...
黑客为什么都有一台笔记本电脑？

黑客为什么都有一台笔记本电脑？

用一位程序员的话俩说&#xff1a;虽然我不是黑客&#xff0c;但是我也喜欢弄一些编程&#xff0c;对我而言&#xff0c;电脑就是我的工具&#xff0c;我的系统里面肯定有许多我自己写的程序&#xff0c;在我做任何操作的时候&#xff0c;我肯定使用我熟悉的软件&#xff0c;这…
阅读更多...
创建者模式—工厂模式

创建者模式—工厂模式

目录 1.工厂模式 1.1概述 1.2简单工厂模式 1.2.1结构 1.2.2实现 1.2.3优缺点 1.2.4静态工厂 1.3工厂方法模式 1.3.1概念 1.3.2结构 1.3.3实现 1.3.4优缺点 1.4抽象工厂模式 1.4.1概念 1.4.2结构 1.4.3实现 1.4.4优缺点 1.工厂模式 1.1概述 需求&#xff1a;设…
阅读更多...
易基因｜细菌全基因组甲基化纳米孔测序(ONT)：技术推介

易基因｜细菌全基因组甲基化纳米孔测序(ONT)：技术推介

大家好&#xff0c;这是专注表观组学十余年&#xff0c;领跑多组学科研服务的易基因。今天跟大家介绍一下易基因的新产品&#xff1a;细菌全基因组甲基化纳米孔测序&#xff08;ONT&#xff09;。表观修饰不需要改变DNA序列便能实现对性状的改变&#xff0c;表观修饰的改变与基…
阅读更多...
什么是事务？什么是索引？什么是视图？

什么是事务？什么是索引？什么是视图？

目录 一、事务 二、视图 1 、视图概念 2、为什么要使用视图 3 、性能问题 4 、定义视图 5、查看视图 6、删除视图 三、索引 1、引入索引的问题 2、索引是什么 3、索引为什么选择b树 一、事务 事务是什么&#xff1f; 事务是一个操作序列&#xff0c;这些操作要么都…
阅读更多...
Python+Selenium+Unittest 之selenium2--元素定位1-简介

Python+Selenium+Unittest 之selenium2--元素定位1-简介

这篇先说下webdriver的几种元素定位方式&#xff0c;让大家有个大概的了解&#xff0c;UI自动化说白了就是使用代码代替人工去进行操作&#xff0c;在页面上&#xff0c;执行人员可以直接对看到的任何地方进行点击、拖动等操作&#xff0c;而代码的话需要识别到到底要点那个按钮…
阅读更多...
生产制造业ERP管理系统对于制造企业的好处有哪些？

生产制造业ERP管理系统对于制造企业的好处有哪些？

任何一家企业在管理当中都存在或多或少的问题&#xff0c;这些问题对企业的发展都形成了一定的阻碍。在生产制造业当中&#xff0c;由于每日的繁重的生产计划和大量的生产作业&#xff0c;使得企业管理存在一些问题&#xff0c;这些问题不利于生产的有序进行&#xff0c;从而阻…
阅读更多...
图表控件LightningChart.NET 系列教程（八）：用代码创建图表

图表控件LightningChart.NET 系列教程（八）：用代码创建图表

LightningChart.NET SDK 是一款高性能数据可视化插件工具&#xff0c;由数据可视化软件组件和工具类组成&#xff0c;可支持基于 Windows 的用户界面框架&#xff08;Windows Presentation Foundation&#xff09;、Windows 通用应用平台&#xff08;Universal Windows Platfor…
阅读更多...
【微服务】分布式事务Seata

【微服务】分布式事务Seata

分布式事务Seata1.分布式事务问题1.1.本地事务1.2.分布式事务2.理论基础2.1.CAP定理2.1.1.一致性2.1.2.可用性2.1.3.分区容错2.1.4.矛盾2.2.BASE理论2.3.解决分布式事务的思路3.初识Seata3.1.Seata的架构3.2.部署TC服务3.3.微服务集成Seata3.3.1.引入依赖3.3.2.配置TC地址3.3.3…
阅读更多...
商用清洁机器人：科沃斯“破圈”、高仙机器人“纵深”

商用清洁机器人：科沃斯“破圈”、高仙机器人“纵深”

配图来自Canva可画 正所谓科技改变生活&#xff0c;机器人在人们日常生活中出现的频率正在逐步提高。同时&#xff0c;随着智能技术的不断迭代升级、用户需求的增多&#xff0c;机器人的应用场景逐步拓宽、功能形态也愈发多样化&#xff0c;比如配送机器人、医疗机器人、教育机…
阅读更多...
Android 12.0 启动app时设置密码锁

Android 12.0 启动app时设置密码锁

1.前言 1.1概述 在12.0的系统产品开发中，对于限制某些app的启动的功能中，在项目中的需求是在点击app启动的时候，根据包名设置密码锁，当输入正确的密码的时候来启动这个app，否则 就不能启动这个app,达到限制使用app的目的，这就需要在app启动的时候，检测app的包名，然后在…
阅读更多...
分布式架构的必问理论

分布式架构的必问理论

基础理论&#xff1a; CAP理论&#xff1a; CAP理论是分布式系统设计中最基础、也是最为关键的理论&#xff0c;它指出&#xff0c;分布式数据存储不可能同时满足以下三个条件。 一致性&#xff08;Consistency&#xff09;&#xff1a;每次读取要么获得最近写入的数据&…
阅读更多...
OAuth2 （二）

OAuth2 （二）

目录 创建项目结构 父工程 客户 认证服务器 资源拥有者 资源服务器 创建项目结构 演示代码下载&#xff1a; https://gitee.com/lisenaq/oauth2-example.git 演示客户发请求&#xff1a; http://localhost:8080/client/getCode 父工程 父工程有:子模块需要重新导入该…
阅读更多...
CVE-2022-34916 Apache Flume 远程代码执行漏洞分析

CVE-2022-34916 Apache Flume 远程代码执行漏洞分析

项目介绍 Apache Flume 是一个分布式的&#xff0c;可靠的&#xff0c;并且可用于高效地收集&#xff0c;汇总和移动大量日志数据的软件。它具有基于流数据流的简单而灵活的体系结构。它具有可调的可靠性机制以及许多故障转移和恢复机制&#xff0c;并且具有健壮性和容错性。它…
阅读更多...
Spring/SpringBoot/SpringCloud面试题

Spring/SpringBoot/SpringCloud面试题

SpringBoot和SpringMVC的区别 形式上&#xff1a;SpringBoot是一个自动化配置的工具&#xff1b;SpringMVC是一个web框架在搭建项目时&#xff1a;SpringMVC需要手动配置xml文件&#xff0c;同时需要配置Tomcat服务器。而SpringBoot采用约定大于配置的方式&#xff0c;进行自动…
阅读更多...
【Linux系统】第五篇：Linux中编译器gcc/g++的使用

【Linux系统】第五篇：Linux中编译器gcc/g++的使用

文章目录一、编译工具gcc/g二、程序编译的过程&#x1f384;预处理&#x1f384;编译&#x1f384;汇编&#x1f384;链接三、动态链接和静态链接&#x1f33b;动态链接&#x1f33b;静态链接&#x1f33b; 程序动、静态链接的区分一、编译工具gcc/g gcc/g 分别是 C/C 的编译器…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023