Java多线程循环打印ABC的5种实现方法

最新推荐文章于 2024-05-08 12:55:53 发布
最新推荐文章于 2024-05-08 12:55:53 发布
阅读量1.9w 收藏 70
点赞数 25
分类专栏： Java多线程 文章标签： Java 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39723337/article/details/80352783
版权

题目：3个线程循环打印ABC，其中A打印3次，B打印2次，C打印1次，循环打印2轮

一.Synchronized同步法

思路：使用synchronized、wait、notifyAll的方法利用线程标记变量控制三个线程的执行顺序。

/**
 * @author XDarker
 * 2018-5-17
 */
public class Main {
	
	public static void main(String[] args) throws InterruptedException {
		
		int num = 1;//当前正在执行线程的标记
		ABCPrint print = new ABCPrint(num); 
		
		Thread threadA = new Thread(new RunnableA(print));
		Thread threadB = new Thread(new RunnableB(print));
		Thread threadC = new Thread(new RunnableC(print));
		threadA.start();
		Thread.sleep(500);
		threadB.start();
		Thread.sleep(500);
		threadC.start();
	}
}
class RunnableA implements Runnable{
	
	private ABCPrint print;
	public RunnableA(ABCPrint print) {
		super();
		this.print = print;	
	}

	@Override
	public void run() {		
		print.PrintA();
		
	}
}
class RunnableB implements Runnable{
	
	private ABCPrint print;
	public RunnableB(ABCPrint print) {
		super();
		this.print = print;
	}

	@Override
	public void run() {		
		print.PrintB();
	}
}
class RunnableC implements Runnable{
	
	private ABCPrint print;
	public RunnableC(ABCPrint print) {
		super();
		this.print = print;
	}

	@Override
	public void run() {		
		print.PrintC();
	}
}
class ABCPrint {

	private int num;//当前正在执行线程的标记
	public ABCPrint(int num) {
		super();
		this.num = num;
	}
	
	
	public void PrintA(){
		for (int j = 0; j < 2; j++)//表示 循环打印2轮
		synchronized(this){
	              while(num != 1){
				try {
					this.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			for (int i = 0; i < 3; i++) {//表示 打印3次
				System.out.println("A");  
			}
			
		    //打印A线程执行完 ，通知打印B线程
                    num = 2;  
                    this.notifyAll();  
	        }
	}
	
	public void PrintB(){
		for (int j = 0; j < 2; j++)//表示 循环打印2轮
		synchronized(this){
			while(num != 2){
				try {
					this.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			for (int i = 0; i < 2; i++) {//表示 打印2次
				System.out.println("B");  
			}
		    //打印B线程执行完 ，通知打印C线程
                    num = 3;  
                    this.notifyAll();  
		}
	}
	
	public void PrintC(){
		for (int j = 0; j < 2; j++)//表示 循环打印2轮
		synchronized(this){
			while(num != 3){
				try {
					this.wait();
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
			}
			
	            System.out.println("C");  
	            //打印C线程执行完 ，通知打印A线程
                    num = 1;  
                    this.notifyAll();  
		}
	}	
}

二.Lock锁方法

思路：Lock锁机制是JDK 5之后新增的锁机制，不同于内置锁，Lock锁必须显式声明，并在合适的位置释放锁。Lock是一个接口，通过ReentrantLock具体实现进行显式的锁操作，即获取锁和释放锁。

/**
 * @author XDarker
 * 2018-5-17
 */
public class Main {
	
	public static void main(String[] args) throws InterruptedException {
		
		int  num = 1;//当前正在执行线程的标记
		ABCPrint print = new ABCPrint(num); 
		
		Thread threadA = new Thread(new RunnableA(print));
		Thread threadB = new Thread(new RunnableB(print));
		Thread threadC = new Thread(new RunnableC(print));
		threadA.start();
		Thread.sleep(500);
		threadB.start();
		Thread.sleep(500);
		threadC.start();
	}
}
class RunnableA implements Runnable{
	
	private ABCPrint print;
	public RunnableA(ABCPrint print) {
		super();
		this.print = print;	
	}

	@Override
	public void run() {		
		print.PrintA();
		
	}
}
class RunnableB implements Runnable{
	
	private ABCPrint print;
	public RunnableB(ABCPrint print) {
		super();
		this.print = print;
	}

	@Override
	public void run() {		
		print.PrintB();
	}
}
class RunnableC implements Runnable{
	
	private ABCPrint print;
	public RunnableC(ABCPrint print) {
		super();
		this.print = print;
	}

	@Override
	public void run() {		
		print.PrintC();
	}
}
class ABCPrint {
	private static final Lock lock = new ReentrantLock();//通过JDK5中的Lock锁来保证线程的访问的互斥
	
	private int num;//当前正在执行线程的标记
	public ABCPrint(int num) {
		super();
		this.num = num;
	}
	
	
	public void PrintA(){
		for (int j = 0; j < 2;)//表示 循环打印2轮
			try {
			    lock.lock();
			    while(num == 1){
				for (int i = 0; i < 3; i++) {//表示 打印3次
				    System.out.println("A");  
		        	}
			       //打印A线程执行完 ，通知打印B线程
		                num = 2;  
		                j++;
			    }
			}finally{//调用了lock方法后，需在finally（finally确保一定会执行，除非执行了exit方法)语句里调用unlock方法。否则会造成死锁等问题
			    lock.unlock();
			}
	}  
	
	public void PrintB(){
		for (int j = 0; j < 2;)//表示 循环打印2轮
		       try{
		            lock.lock();
			    while(num == 2){
				for (int i = 0; i < 2; i++) {//表示 打印2次
					System.out.println("B");  
				}
			        //打印B线程执行完 ，通知打印C线程
	                        num = 3;  
	                        j++;	    
		        }finally{
			    lock.unlock();
		        }	
	}
	
	public void PrintC(){
		for (int j = 0; j < 2;)//表示 循环打印2轮
			try{
			    lock.lock();
			    while(num == 3){
			       System.out.println("C"); 
			       //打印C线程执行完 ，通知打印A线程
		               num = 1;  
		               j++;
	                    }  
			}finally{
			    lock.unlock();
			}
	}
	
}

三.ReentrantLock结合Condition

思路：Condition中的await()方法相当于Object的wait()方法，Condition中的signal()方法相当于Object的notify()方法。Condition它更强大的地方在于：能够更加精细的控制多线程的休眠与唤醒。对于同一个锁，我们可以创建多个Condition，在不同的情况下使用不同的Condition。

/**
 * @author XDarker
 * 2018-5-17
 */
public class Main{

	public static void main(String[] args) {
		
		final AlternateDemo ad = new AlternateDemo();
		
		new Thread(new Runnable() {
			
			@Override
			public void run() {
				for (int i = 0; i < 2; i++) {
					ad.loopA(i);
				}
				
			}
		},"A").start();
		
		new Thread(new Runnable() {
					
					@Override
					public void run() {
						for (int i = 0; i < 2; i++) {
							ad.loopB(i);
						}
						
					}
				},"B").start();

		new Thread(new Runnable() {
			
			@Override
			public void run() {
				for (int i = 0; i < 2; i++) {
					ad.loopC(i);
				}
			}
		},"C").start();
		
	}
	
}

class AlternateDemo{
	
	private int num = 1;//当前正在执行线程的标记
	
	private Lock lock =  new ReentrantLock();
	
	private Condition condition1 = lock.newCondition();
	private Condition condition2 = lock.newCondition();
	private Condition condition3 = lock.newCondition();
	
	public void loopA(int loop){
		
		lock.lock();
		
		try {
			//1.判断
			if(num != 1){
				condition1.await();
			}
			
			//2.打印
			for (int i = 0; i < 3; i++) {
				System.out.println(Thread.currentThread().getName()+"-"+"第"+loop+"轮"+"-第"+i+"次");
			}
			
			//3.唤醒
			num = 2;
			condition2.signal();
		} catch (Exception e) {
			// TODO: handle exception
		}finally{
			lock.unlock();
		}
	}
	
	public void loopB(int loop){
		
		lock.lock();
		
		try {
			//1.判断
			if(num != 2){
				condition2.await();
			}
			
			//2.打印
			for (int i = 0; i < 2; i++) {
				System.out.println(Thread.currentThread().getName()+"-"+"第"+loop+"轮"+"-第"+i+"次");
			}
			
			//3.唤醒
			num = 3;
			condition3.signal();
		} catch (Exception e) {
			// TODO: handle exception
		}finally{
			lock.unlock();
		}
	}

	public void loopC(int loop){
	
	lock.lock();
		
		try {
			//1.判断
			if(num != 3){
				condition3.await();
			}
			
			//2.打印
			for (int i = 0; i < 1; i++) {
				System.out.println(Thread.currentThread().getName()+"-"+"第"+loop+"轮"+"-第"+i+"次");
			}
			System.out.println("---------------------------");
			//3.唤醒
			num = 1;
			condition1.signal();
		} catch (Exception e) {
			// TODO: handle exception
		}finally{
			lock.unlock();
		}
	}
}

四.AtomicInteger方法

思路：AtomicInteger，一个提供原子操作的Integer的类。在Java中，++i和i++操作并不是线程安全的，在使用的时候，不可避免的会用到synchronized关键字。而AtomicInteger则通过一种线程安全的加减操作接口。

/**
 * @author XDarker
 * 2018-5-17
 */
public class Main {

	public static void main(String[] args) {
		new ABCPrint("A",3).start();//A打印3次
		new ABCPrint("B",2).start();//B打印2次
		new ABCPrint("C",1).start();//C打印1次
	}
	
}

class ABCPrint extends Thread {
	
	//打印次数
	private int count;

	private final String str[] = { "A", "B", "C" };
	private final static AtomicInteger  atomCount= new AtomicInteger();

	public ABCPrint(String name,int count) {
		this.setName(name);
		this.count = count;
	}

	@Override
	public void run() {
		while (true) {
			// 循环满2轮退出打印
			if (atomCount.get() / 3 == 2) {
				break;
			}
			synchronized (atomCount) {
				// 顺序打印A、B、C
				if (str[atomCount.get() % 3].equals(getName())) {
					atomCount.getAndIncrement();//自增
					
					//对应打印几次 
					for (int i = 0; i < count; i++) {
						System.out.println(getName());
					}
					
					//表示一轮打印结束 方便观察打印下分隔符
					if ("C".equals(getName())) {
						System.out.println("================================");
					}
					// 当前线程打印打印完成后唤醒其它线程
					atomCount.notifyAll();
				} else {
				// 非顺序线程wait()
					try {
						atomCount.wait();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
				}
			}
		}
	}

}

五.Semaphore信号量方式

思路： 信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施, 它负责协调各个线程, 以保证它们能够正确、合理的使用公共资源。Semaphore线程同步机制，当调用acquire()时，内部计数器数值增加；调用release()时，内部计数器递减；计数器值不能小于0，如果等于0，acquire()方法被阻塞，需要等待其他线程调用release()方法。

/**
 * @author XDarker
 * 2018-5-17
 */
public class Main {
	
	 public static void main(String[] args) throws InterruptedException {
	        new ThreadA(3).start();
	        new ThreadB(2).start();
	        new ThreadC(1).start();
	   }
	 
	//以A开始的信号量,初始信号量数量为1
    private static Semaphore A = new Semaphore(1);
    //B、C信号量,A完成后开始,初始信号数量为0
    private static Semaphore B = new Semaphore(0);
    private static Semaphore C = new Semaphore(0);


    static class ThreadA extends Thread {
    	private int count;
        public ThreadA(int count) {
			super();
			this.count = count;
		}
		@Override
        public void run() {
            try {
                for (int i = 0; i < 2; i++) {
                    A.acquire();// A获取信号执行,A信号量减1,当A为0时将无法继续获得该信号量
                    for (int j = 0; j < count; j++) {
                    	   System.out.print("A");
					}
                 
                    B.release();// B释放信号，B信号量加1（初始为0），此时可以获取B信号量
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    static class ThreadB extends Thread {
    	private int count;
        public ThreadB(int count) {
			super();
			this.count = count;
		}
        @Override
        public void run() {
            try {
                for (int i = 0; i < 2; i++) {
                    B.acquire();
                    for (int j = 0; j < count; j++) {
                    	System.out.print("B");
					}
                    C.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    static class ThreadC extends Thread {
    	private int count;
        public ThreadC(int count) {
			super();
			this.count = count;
		}
        @Override
        public void run() {
            try {
                for (int i = 0; i < 2; i++) {
                    C.acquire();
                    for (int j = 0; j < count; j++) {
                    	System.out.println("C");
					}
                    A.release();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
   
}

 

XDarker
关注
  • 25
    点赞
  • 踩
  • 70
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
用三个线程按顺序循环打印abc三个字母，比如abcabcabc（四种方式实现
m0_60707660的博客
03-23 1026
虽然面试套路众多，但对于技术面试来说，主要还是考察一个人的技术能力和沟通能力。不同类型的面试官根据自身的理解问的问题也不尽相同，没有规律可循。上面提到的关于这些JAVA基础、三大框架、项目经验、并发编程、JVM及调优、网络、设计模式、spring+mybatis源码解读、Mysql调优、分布式监控、消息队列、分布式存储等等面试题笔记及资料。
多线程交替打印ABC的多种实现方法
热门推荐
想作会飞的鱼的博客
08-17 6万+
一、题目描述建立三个线程A、B、C，A线程打印10次字母A，B线程打印10次字母B,C线程打印10次字母C，但是要求三个线程同时运行，并且实现交替打印，即按照ABCABCABC的顺序打印。二、Synchronized同步法1、基本思路使用同步块和wait、notify的方法控制三个线程的执行次序。具体方法如下：从大的方向上来讲，该问题为三线程间的同步唤醒操作，主要的目的就是ThreadA->Thre
2024年最新Java多线程循环打印ABC等问题（三种方式），java面试常问知识点
最新发布
2401_84557849的博客
05-08 614
大家不妨直接在牛客和力扣上多刷题，同时，我也拿了一些面试题跟大家分享，也是从一些大佬那里获得的，大家不妨多刷刷题，为金九银十冲一波！本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录需要这份系统化的资料的朋友，可以点击这里获取。
Java多线程循环打印ABC等问题
笔记小屋
05-22 1116
前言 有很多中写法，希望可以慢慢都写出来。 思路 利用一个计数来除线程个数得到余数从而控制线程输出，并且利用一个Object的wait()和notify()方法来对线程的阻塞和唤醒，这里的技巧可以看看。 wait() 阻塞当前线程，等待被释放，继续执行当前线程 notify() 唤醒监视该对象的第一个线程，notifyAll()唤醒监视该对象的所有线程。 代码： static volatile int state; // 线程共有，判断所有的打印状态 static final Obje
java代码怎么打印松树_JAVA 多线程打印的几种方法
weixin_32822843的博客
02-06 173
在面试中遇到了这个问题 ，这个问题主要考面试者的多线程相关的知识，包括但不限于wait/notify 锁 Volatile变量3个方面。3个线程 循环打印ABC 10次第一种实现 Volatile 实现 依靠共同的state变量来保证 需要轮询public class ThreadForDemo {private static volatile int threestate=0;stati...
java多线程循环打印abc,多线程循环打印ABC
weixin_29707757的博客
03-10 184
public class Print {private int flag = 1;synchronized public void printA(){if(flag == 1){System.out.print("A");flag = 2;try {this.notifyAll();} catch (Exception e) {e.printStackTrace();}}else{try {thi...
用java实现打印功能
andnnl的专栏
03-13 7753
 用java实现打印，java.awt中提供了一些打印的API,要实现打印，首先要获得打印对象，然后继承Printable实现接口方法print，以便打印机进行打印，最后用用Graphics2D直接输出直接输出。下面代码实现了简单的打印功能：import java.awt.BasicStroke;import java.awt.Color;import java.awt.Component;i
Java多线程连续打印abc实现方法详解
08-19
Java多线程连续打印abc实现方法详解是 Java 编程语言中的一种常见问题，旨在解决三个线程同时执行，要求打印出10个连着的abc的难题。该问题的解决方案需要使用同步机制来确保三个线程的顺序执行。 知识点一：多线程...
java多线程实现有序输出ABC
08-25
java多线程实现有序输出ABC是java多线程编程中的一种常见问题，它的本质是控制线程的执行顺序，实现线程之间的同步和通信。在java中，可以使用多种方式来实现多线程的有序输出，以下我们将详细介绍两种常见的实现...
Java试题及答案abc.doc
09-30
在Java编程语言中，有许多关键...这些题目涵盖了Java中的基本概念，如类的继承、接口、数据类型、数组、字符串、图形绘制、输入/输出流、布局管理器、多线程以及内存管理等。理解这些知识点对于掌握Java编程至关重要。
java多线程实现轮流打印ABC
05-24
使用多线程和阻塞队列实现了ABC字母按顺序轮流打印
java 计算机编程笔记
12-02
Java是一种广泛使用的面向对象的编程语言，其设计目标是具有高度的可移植性，可编写一次，到处运行。...通过不断地学习和实践，可以深入理解Java语言的高级特性，如面向对象编程、异常处理、多线程、网络编程等。
Java用三个线程按顺序循环打印 abc 三个字母,比如 abcabcabc。
weixin_41704428的博客
05-28 6631
这是一道经典的Java多线程面试题。自己写了一种较为巧妙的方法：package JavaDay5_27; import java.util.Collections; /** * @author myvina@qq.com * @date 18-5-27 下午8:00 */ public class Demo1 { public static void main(String[...
Java用三个线程按顺序循环打印 abc 三个字母,比如 abcabcabc。(再尝试）
weixin_41704428的博客
05-29 4188
    之前的文章（点击打开链接）中解决此问题使用的同步代码块，本次使用的线程安全类来顺序输出，并还能认识到一个Java异常和抛出异常的原因。    线程安全类代码：package JavaDay5_29; /** * @author myvina@qq.com * @date 18-5-29 上午10:28 */ public class PrintLetter { priv...
Java多线程循环打印ABC等问题（三种方式）
m0_75232472的博客
04-03 1046
总体来说，如果你想转行从事程序员的工作，Java开发一定可以作为你的第一选择。但是不管你选择什么编程语言，提升自己的硬件实力才是拿高薪的唯一手段。如果你以这份学习路线来学习，你会有一个比较系统化的知识网络，也不至于把知识学习得很零散。我个人是完全不建议刚开始就看《Java编程思想》、《Java核心技术》这些书籍，看完你肯定会放弃学习。建议可以看一些视频来学习，当自己能上手再买这些书看又是非常有收获的事了。《一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码》点击传送门即可获取！
面试算法题：三线程循环打印ABC
又听凌晨的钟声
04-28 3745
面试遇到三线程循环打印ABC的题目，当时没写出来，然后经过查阅，进行整理了一下。 1、题目 有A、B、C 三个线程，A线程 输出“A”，B线程 输出“B”，C线程 输出“C”，要求同时启动3个线程，按照顺序输出“ABC”，循环10次，请使用代码实现。 2、问题分析 A、B、C 三个线程；这表示我们要使用多线程同步，有人说了这不废话吗。是的，笔者只是想说，多线程的实现，有几种方式，①继承Threa...
三个线程轮流打印ABC
Infor_learning的博客
07-14 6782
1、多线程if和where的区别： 就是用if判断的话，唤醒后线程会从wait之后的代码开始运行，但是不会重新判断if条件，直接继续运行if代码块之后的代码，而如果使用while的话，也会从wait之后的代码运行，但是唤醒后会重新判断循环条件，如果不成立再执行while代码块之后的代码块，成立的话继续wait。 2、 一.概述wait()方法可以使线程进入等待状态，而notify()可以使等待的状态唤醒 wait，notify和notifyAll方法是Object类的成员函数，所以Java的任何一个.
java 使用信号量实现任意n个线程的交替打印
shenkunchang1877的博客
09-02 419
思路：给每个线程配一个信号量，后一个线程等前一个释放，第一个等最后一个释放，形成循环等待链，然后手动给第一个线程释放一个信号量使得程序执行起来 import java.util.concurrent.Semaphore; public class mutil_print { public static volatile int i; public static int nums; public static class TA implements Runnable{ ...
java多线程每个线程挨着打印abc的4种实现方式
08-30
Java多线程每个线程挨着打印abc的4种实现方式如下： 1. 使用同步方法： 在一个类中创建一个共享的锁对象。创建3个线程，分别调用该对象的3个同步方法，在每个方法中使用循环打印对应的字符，然后调用notifyAll()方法唤醒其他两个线程，最后调用wait()方法当前线程进入等待状态。 2. 使用synchronized关键字： 在一个类中创建一个共享的锁对象，并使用synchronized关键字修饰方法。创建3个线程，分别调用该对象的3个同步方法，在每个方法中使用循环打印对应的字符，然后调用notifyAll()方法唤醒其他两个线程，最后调用wait()方法当前线程进入等待状态。 3. 使用Lock和Condition接口： 创建一个ReentrantLock对象和3个Condition对象。创建3个线程，分别获取对应的Condition对象，然后在循环中使用Lock对象的lock()方法获取锁，使用对应的Condition对象的await()方法等待，直到该线程被唤醒后打印对应的字符，并调用其他两个Condition对象的signalAll()方法唤醒其他两个线程。 4. 使用信号量Semaphore： 创建一个Semaphore对象和3个线程。在每个线程中使用Semaphore对象的acquire()方法获取许可，然后在循环中打印对应的字符，最后调用Semaphore对象的release()方法释放许可，并通知其他两个线程获取许可。 以上这四种方式都可以实现多线程每个线程挨着打印abc的效果。然而，具体的选择取决于实际情况，例如需要考虑线程的数量、同步机制的复杂度、线程间协作的方式等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值