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

最新推荐文章于 2024-07-09 17:55:47 发布
最新推荐文章于 2024-07-09 17:55:47 发布
阅读量135 收藏 1
点赞数
文章标签： java 面试 jvm 开发语言 职场和发展
原文链接：https://mp.weixin.qq.com/s?__biz=MzAxNjk4ODE4OQ==&mid=2247535566&idx=2&sn=8e319918357e0c8832bf6aa157467c70&chksm=9bee6abcac99e3aa98257042bff4e0b375529b20024d968670c3048734e97af670a1360d59bd&scene=126&sessionid=0
版权

点击关注公众号，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） -> 核对通知的暗号 -> 打印->然后修改暗号-> 发出携带暗号通知（让别的线程认领）

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

简图：

c1f1d8976be00a5af0fe6c4d7f39f377.png

三个线程的一举一动 ：

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

效果：

69bde332e5a1e46461ab4a9c67949569.png

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

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

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

ok，代码稍作调整 ：

加上2个值

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

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

1ef3a1e52aeee5baab6acf4c9c9a0564.png

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

5ff3be96d96d7be58e3d08a39dd07ad2.png

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

fc7a6873cc38b072905f4eb018adb228.png

看看效果：

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

代码简析：

9d1e8c1d1a3c4210b848f4b00c8d7270.png

看看效果:

1e7f8aba5f0ce1cb298219be04e3dba3.png

好了，该篇就到这吧。

作者：小目标青年

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

details/128828799

热门内容：
 
 
bc91d93bac8e4b66e98a3cd7bb4a4c50.jpeg
 
 
 
 
最近面试BAT，整理一份面试资料《Java面试BAT通关手册》，覆盖了Java核心技术、JVM、Java并发、SSM、微服务、数据库、数据结构等等。
获取方式：点“在看”，关注公众号并回复 666 领取，更多内容陆续奉上。
 
 
明天见(｡･ω･｡)
 


                

        

        

    

  


    

      

        

            

              
                
                  公众号:方志朋
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
java三个线程交替打印数字(利用原子类)

				
			

			

				

					tomorrow_shoe的博客
				

				

					03-11
					
					740
					
				

			

		

		

			
				
可以采用的方法有使用synchronized采用对操作数的加减进行加锁；
也可以采用原子类，因为原子类使用的CAS原理实现，性能独占锁性能高。
package test;

import java.util.concurrent.atomic.AtomicInteger;

public class z {
	public static void main(String[] args) {
		f...

			
		

	



                

            
              



	

		

			

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

				
			

			

				

					m0_71777195的博客
				

				

					03-25
					
					176
					
				

			

		

		

			
				
接到携带暗号的通知（默认暗号为 A） -> 核对通知的暗号 -> 打印->然后修改暗号-> 发出携带暗号通知（让别的线程认领）当然如果需要他们不这么无休止，只需要 做一个标识进行判断就好，例如 加在一起已经打印够100次了，就停止 之类的限制值。那就是 线程A 负责打印 A ，线程 B 负责打印 B ，线程C 负责打印 C。有打印 ABC 的， 有打印 123 的， 有打印到100的。同样，如果是线程C打印完，就把通知改回A，继续发通知。举例， 如果交替打印，到100 就停止， 也就是。

			
		

	



              


  
              

                


	

		

			

				
					
Java面试题：三个线程交替打印ABC如何实现？

					
最新发布

				
			

			

				

					彭世瑜的博客
				

				

					07-09
					
					452
					
				

			

		

		

			
				
【代码】Java面试题：三个线程交替打印ABC如何实现？

			
		

	





	

		

			

				
					
Java面试题：多个线程交替执行

				
			

			

				

					web13618542420的博客
				

				

					04-04
					
					829
					
				

			

		

		

			
				
Java面试题：多个线程交替执行
文章目录

Java面试题：多个线程交替执行


前言
项目环境
1.Condition 版本
2.公平锁
3.如何解决线程打印顺序的问题



前言
最近在一些技术群里看到有很多小伙伴面试的时候碰到这个多线程的笔试题，实现两个线程交替打印，或者是实现多个线程的交替打印这种类似的题目。
本文提供三种解题思路和实现

利用 Condition 类实现
利用公平锁实现
超过 2 个线程，利用队列来保证线程执行的顺序

项目环境

jdk 1.8
github 地址：https:

			
		

	



		

			
		



	

		

			

				
					
java实现三个线程交替打印ABC

				
			

			

				

					或左的博客
				

				

					07-05
					
					1500
					
				

			

		

		

			
				
使用Semaphore
思路, 三个信号量, a控制b, b控制c, c控制a
初始情况, a开启, bc关闭
public class printByTurn {

    private static Semaphore[] semaphores = new Semaphore[3];
    

    static {//初始情况
        for(int i=0; i<semaphores.length; i++){
            if(i==0) semaphores[i]

			
		

	





	

		

			

				
					
三个线程交替打印ABC（java）

				
			

			

				

					gyxx1998的博客
				

				

					08-25
					
					998
					
				

			

		

		

			
				
三个线程交替打印ABC（sychronized和reentranceLock）

			
		

	





	

		

			

				
					
老掉牙的问题：二叉树的遍历

				
			

			

				

					08-19
				

			

		

		

			
				
二叉树的三种遍历的递归和非递归方法，语言种类，C++，如果有不足的地方，请与作者联系，谢谢。

			
		

	





	

		

			

				
					
JAVA开发需求分析套路_需求分析：我走过最长的路，就是需求的套路

				
			

			

				

					weixin_39709178的博客
				

				

					02-24
					
					865
					
				

			

		

		

			
				
面对千变万化的需求，也许很难抽象出一套普适的方法论，不妨一起来看看需求分析过程中的那些常见套路，或许能有一些值得借鉴和思考。“我走过最长的路，就是需求的套路。”—— 某PM前辈已经记不得说话这兄弟的名字，只是眼前偶尔还闪过他有些血丝的干涸眼神，在那个连续996后有些乌烟瘴气的会议室，他摁灭烟头时从嘴角挤出的的几个字，随着烟圈和哄笑散开，让原本压抑的气氛多了几分无奈和尴尬。作为一名产品经理，有幸逃过...

			
		

	





	

		

			

				
					
备战秋招，涵盖二十九大技术栈Java面试最新八股文来袭，2022金九银十成功上岸拿下offer

				
			

			

				

					Q54665642ljf的博客
				

				

					08-10
					
					953
					
				

			

		

		

			
				
2022秋招眼看着就要来了，很多同学开始感受到压力，着急金九银十的秋招，所以纷纷临时抱佛脚，开始在找有没有什么提升面试成功率，查漏补缺的方法。
我的回答是： 有！
说起来，临阵磨枪没有比背八股文更靠谱的了，很多人对这个很不屑： 呵，背题家罢了！
但国内大环境如此，你不背，你就找不到满意的工作，很现实的一个事情。当然，你可以选择出淤泥而不染，身体力行的表示反抗，对推动国内互联网陋习改革出一份力，那我还是很佩服的。
郑重承诺 ：
文中所有资料完全免费分享，文末有资料获取方式
这些面试资料都是我通过各种渠道收..

			
		

	





	

		

			

				
					
【JAVA并发】多个线程交替打印

				
			

			

				

					qq_27198345的博客
				

				

					09-13
					
					1395
					
				

			

		

		

			
				
多线程交替打印

			
		

	





	

		

			

				
					
java实现两个线程交替打印的实例代码

				
			

			

				

					08-25
				

			

		

		

			
				
在本篇文章里小编给大家整理的是一篇关于java实现两个线程交替打印的相关知识点内容，有需要的朋友们参考下。

			
		

	





	

		

			

				
					
使用Java实现三个线程交替打印0-74

				
			

			

				

					weixin_30385925的博客
				

				

					06-03
					
					485
					
				

			

		

		

			
				
使用Java实现三个线程交替打印0-74
题目分析
 三个线程交替打印，即3个线程是按顺序执行的。一个线程执行完之后，唤醒下一个线程，然后阻塞，等待被该线程的上一个线程唤醒。执行的顺序是一个环装的队列 0->1->2->0 ....->0->1->2
实现思路
  由于三个线程一次只能有一个在打印数字，所以需要用一个锁来进行同步。但是在打印时要保证顺序...

			
		

	





	

		

			

				
					
Java多线程交替打印

				
			

			

				

					weixin_47493863的博客
				

				

					04-22
					
					558
					
				

			

		

		

			
				
Java多线程交替打印，Java多线程交替执行。

			
		

	





	

		

			

				
					
java三线程交替打印123……n

				
			

			

				

					孤星可
				

				

					03-11
					
					2312
					
				

			

		

		

			
				
使用多线程交替打印1--n，a进程打印1,4,7,……（3n+1）,b进程打印2,7,10,……（3n+2）,c进程打印3,6,9,……（3n）
涉及到多线程的同步，阻塞，wait,notify


代码如下
Num.java
public class Num {
	private int num = 0;

	public Num(int num) {
		this.num = nu

			
		

	





	

		

			

				
					
java多线程交替打印_使用Java实现三个线程交替打印0-74

				
			

			

				

					weixin_34055902的博客
				

				

					02-12
					
					891
					
				

			

		

		

			
				
使用Java实现三个线程交替打印0-74题目分析三个线程交替打印，即3个线程是按顺序执行的。一个线程执行完之后，唤醒下一个线程，然后阻塞，等待被该线程的上一个线程唤醒。执行的顺序是一个环装的队列 0->1->2->0 ....->0->1->2实现思路由于三个线程一次只能有一个在打印数字，所以需要用一个锁来进行同步。但是在打印时要保证顺序就要求 一个线程打印完之...

			
		

	





	

		

			

				
					
Java多线程交替打印模板

				
			

			

				

					qq_40739476的博客
				

				

					11-26
					
					549
					
				

			

		

		

			
				
Java、多线程、交替打印、线程通信

			
		

	





	

		

			

				
					
Java多线程 - 交替打印问题

				
			

			

				

					朝阳大司马
				

				

					09-14
					
					627
					
				

			

		

		

			
				
Java多线程 - 交替打印问题

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值