服务粉丝

我们一直在努力
当前位置：首页 > 财经 >

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

日期： 来源：Java知音收集编辑：小目标青年

一个老掉牙的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();
    }
}

代码简析：

看看效果:

好了，该篇就到这吧。

作者：小目标青年

来源：blog.csdn.net/qq_35387940/article/

details/128828799

推荐

Java面试题宝典

技术内卷群，一起来学习！！

PS：因为公众号平台更改了推送规则，如果不想错过内容，记得读完点一下“在看”，加个“星标”，这样每次新文章推送才会第一时间出现在你的订阅列表里。点“在看”支持我们吧!

文章推荐

相关阅读

  • ChatGPT 王炸更新，有点操作系统的雏形了....

  • OpenAI 宣布已经在 ChatGPT 中实现了对插件的初步支持。插件 (Plugins) 是专门为语言模型设计的工具，以安全为核心原则，可帮助 ChatGPT 访问最新信息、运行计算或使用第三方服

  • 互联网大事件：Docker翻脸，不再开源！

  • 前几日，Docker Hub出了一件大事！但凡创建了“organisation”的用户都收到了一封含有简短PDF链接的邮件。邮件的内容“金钱味”十足：如果不按照要求升级付费，用户就将失去对数据

  • Mybatis 批量插入大量数据的最优方案

  • Mybatis批量插入的方式有三种普通插入foreach 优化插入ExecutorType.BATCH插入下面对这三种分别进行比较:1.普通插入默认的插入方式是遍历insert语句，单条执行，效率肯定低下，如

  • 边关的星空，美到窒息→

  • 文图丨宫子渊、索延客夜晚你会抬头数星星吗？还记得漫天繁星下许过的愿望吗？与星辰为伴可以感受到星河的广袤与无垠体验夜空里的静谧与美好品味夜晚带给你的浪漫走今天带你去看

  • 他一家四代从军，当兵三年就立功

  • 文图丨刘关飞、袁　笑四代从军志不改薪火相传报国情这个家庭
    四代人身着戎装、步履铿锵在不同的年代书写着相同的信仰和情怀
    仲春时节，在76集团军某旅驾驶员复训考核现场，中

  • 海口一安居房4月2日开展选房！交付时间→

  • 新海南客户端、南海网、南国都市报记者：党朝峰3月24日，海口市住建局发布海口文庭居安居房项目第一批房源申购对象、房源信息、选房方案及征集摇顺序号代表的公告，确保配售选房

聚合标签

中国 自己的 美国 都是 疫情 的人 亿元 的是 三星 手机 华为 这款 车型 万元 企业 日本 小米 俄罗斯 项目 民警

热门文章

  • “复活”半年后　京东拍拍二手杀入公益事业

  • 京东拍拍二手“复活”半年后，杀入公益事业，试图让企业捐的赠品、家庭闲置品变成实实在在的“爱心”。 把“闲置品”变爱心 6月12日，“益心一益·守护梦想每一步”2018年四

最新文章

  • 又得准备面试了~

  • 大家好，最近有不少小伙伴在后台留言，又得准备面试了，不知道从何下手！新的一年需要抓住新的机会，不论是跳槽涨薪，还是学习提升！先给自己定一个小目标，然后再朝着目标去努力就完事儿了

  • ChatGPT 王炸更新，有点操作系统的雏形了....

  • OpenAI 宣布已经在 ChatGPT 中实现了对插件的初步支持。插件 (Plugins) 是专门为语言模型设计的工具，以安全为核心原则，可帮助 ChatGPT 访问最新信息、运行计算或使用第三方服

  • 互联网大事件：Docker翻脸，不再开源！

  • 前几日，Docker Hub出了一件大事！但凡创建了“organisation”的用户都收到了一封含有简短PDF链接的邮件。邮件的内容“金钱味”十足：如果不按照要求升级付费，用户就将失去对数据