java多线程中两个线程交替运行，分别输出奇偶数

最新推荐文章于 2025-05-03 17:36:21 发布
置顶 最新推荐文章于 2025-05-03 17:36:21 发布
阅读量906 收藏 6
点赞数 1
文章标签： 多线程 java 并发编程 sync
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_43819927/article/details/106295311
版权
本文介绍了如何在Java中实现两个线程交替执行，一个输出奇数，一个输出偶数。分别使用synchronized关键字、自旋锁、LockSupport工具类以及Lock和Condition接口的方法，详细阐述了各自的实现原理和特点。同时，文章还扩展讨论了如何编写程序，让3个线程按照特定顺序(A-B-C)交替打印。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

问题：java中两个线程交替执行，一个输出奇数，一个输出偶数

方法一：
看到题目时，我第一个想到的是用synchronized加锁，然后使用notify唤醒线程和wait阻塞线程
通过 synchronized 锁定对象，每次只能有一个线程进入，每打印一个数，就释放锁，另一个线程进入，拿到锁，打印，唤醒另一个线程，然后挂起自己。循环反复，实现了一个最基本的打印功能。

public class Text1 {
	   private static int state=1;
	public static void main(String[] args) {
		final Text1 text1=new Text1();
	
		new Thread(new Runnable() {
			public void run() {
				synchronized (text1) {
					while(state!=1){//当state！=1是，说明不该线程1打印，则将线程1挂起，让线程2执行打印
						try {
							text1.wait();
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}	
					
					for(int i=1;i<=100;i=i+2){
						System.out.println(i);//当线程1打印之后，该线程2打印了，此时将状态state置为2
						state=2;             //唤醒线程2，并使用wait交出锁资源，线程2执行打印
						try {
							text1.notify();
							text1.wait();
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
					//text1.notify();
				}
				
			}
		
	}).start();
		
		new Thread(new Runnable() {
			public void run() {
				synchronized (text1) {	
					while(state!=2){//当state！=2，说明不该线程2执行，则将线程2挂起，让线程1执行打印
						try {
							text1.wait();
						} catch (InterruptedException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
					}
					
				for(int i=2;i<=100;i=i+2){
					System.out.println(i);//线程2打印完成之后将state置为1，将线程1唤醒，并使用wait交出锁
					state=1;
					try {
						text1.notify();
						text1.wait();
					} catch (InterruptedException e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}
				}
				text1.notify();
			}
		}
	}).start();
		
	}
}

方法二：
自旋锁的方式，就是我们没有用锁，相当于自己写了一个自旋锁，利用CAS原理

  public class Text1 {
	static  volatile int state=1;
	public static void main(String[] args) {
		
		new Thread(new Runnable() {
			public void run() {
				for(int i=1;i<=100;i=i+2){
					while(state!=1){//当state！=1时，说明此时不该线程1打印，则陷入循环等待线程2将state改为1后立即执行打印
					}
					System.out.println(i);
					state=2;
				}
				
			}
		}).start();
		
		new Thread(new Runnable() {
			public void run() {
				for(int i=2;i<=100;i=i+2){
					while(state!=2){//当state！=2时，说明此时不该线程2打印，则陷入循环等待线程1执行完打印之后将state该为2（volatial可见性），再执行打印
						
					}
					System.out.println(i);
					state=1;
				}
				
			}
		}).start();
		
	}
}

方法三：
使用LockSupport，LockSupport是一个比较底层的工具类，用来创建锁和其他底层工具类的基本线程阻塞原语
LockSupport的特点：

  1. 不需要synchronized加锁就可以实现线程阻塞和唤醒。

  2. LockSupport的unpark()可以先与park()运行，并且线程不会阻塞。
    unpark() 唤醒线程 park() 阻塞线程

  3. 如果一个线程处于等待状态，连续调用了两次park()方法，就会是线程永远无法被唤醒

public class Text1 {
	   static Thread t1=null;
	   static Thread t2=null;
	public static void main(String[] args) { 
		 t1=new Thread(new Runnable() {
			public void run() {
				for(int i=1;i<=100;i=i+2){
					System.out.println(i);
					LockSupport.unpark(t2);//t1打印完唤醒t2
					LockSupport.park();//t1阻塞
					
				}
				
			}
		},"t1");
		
		t2=new Thread(new Runnable() {
			public void run() {
				for(int i=2;i<=100;i=i+2){
					LockSupport.park(); //阻塞t2
					System.out.println(i);
					LockSupport.unpark(t1);
			   }
			}
		},"t2");
		
		t1.start();
		t2.start();
	}

}

方法四：
使用Lock和Condition类来完成，Condition是Java提供了来实现等待/通知的类，Condition对象是由lock对象所创建的,但是同一个锁可以创建多个Condition的对象，即创建多个对象监视器。这样的好处就是可以指定唤醒线程。notify或notifyALL唤醒的线程是随机唤醒一个。

public class Text1 {
	  static Lock lock=new ReentrantLock();
	  static Condition conditionT1=lock.newCondition();
	  static Condition conditionT2=lock.newCondition();
	  public static void main(String[] args) {
		  
		  
		  new Thread(new Runnable() {
			public void run() {
				try {
					lock.lock();
					for(int i=1;i<=100;i=i+2){
						System.out.println(i);
						conditionT2.signal();
						conditionT1.await();
						
					}
					conditionT1.signal();
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}finally {
					lock.unlock();
				}
				
			}
		}).start();
		  
		  new Thread(new Runnable() {
				public void run() {
					try {
						lock.lock();
						for(int i=2;i<=100;i=i+2){
							System.out.println(i);
							conditionT1.signal();
							conditionT2.await();
							
						}
						conditionT2.signal();
					} catch (Exception e) {
						// TODO Auto-generated catch block
						e.printStackTrace();
					}finally {
						lock.unlock();
					}
				}
			}).start();
		
	}
}

**扩展：**编写一个程序，开启 3 个线程，每个线程分别打印A,B,C,要求线程每次打印都按照A–>B–>C的顺序来打印
如：ABCABCABC…… 依次递归

class ShareDate{
	static int num=1;//标志位，t1:1,t2:2,t3:3
	 //获得lock锁
	  static Lock lock=new ReentrantLock();
	  //创建三个condition对象用来await(阻塞)和signal(唤醒)指定的线程
	  private Condition c1=lock.newCondition();
	  private  Condition c2=lock.newCondition();
	  private  Condition c3=lock.newCondition();
	  
	  public void printA(){
		  lock.lock();
		  try {
			//判断
			while(num!=1){
				c1.await();
			}
			//干活
			System.out.println(Thread.currentThread().getName()+"-A");
			//通知
			num=2;//先修改标志位
			c2.signal();//唤醒第二个线程
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally {
			lock.unlock();
		}
		 
		  System.out.println();
		  
	  }
      public void printB(){
    	  lock.lock();
    	  try {
			while(num!=2){
				c2.await();
			}
			System.out.println(Thread.currentThread().getName()+"-B");
			num=3;
			c3.signal();
		} catch (Exception e) {
			// TODO: handle exception
		}finally{
			lock.unlock();
		}
		  
	  }
     public void printC(){
	  lock.lock();
	  try {
		while(num!=3){
			c3.await();
		}
		System.out.println(Thread.currentThread().getName()+"-C");
		num=1;
		c1.signal();
	} catch (Exception e) {
		// TODO: handle exception
	}finally{
		lock.unlock();
	}
	  
  }
	  
}
public class Text1 {  
  public static void main(String[] args) {
	  final ShareDate shareDate=new ShareDate();
	  new Thread(new Runnable() {
		public void run() {
			for(int i=1;i<=10;i++){
				shareDate.printA();
			}
		}
	}).start();
	  
	  
	  new Thread(new Runnable() {
			public void run() {
				for(int i=1;i<=10;i++){
					shareDate.printB();
				}
			}
		}).start();
	  
	  new Thread(new Runnable() {
			public void run() {
				for(int i=1;i<=10;i++){
					shareDate.printC();
				}	
			}
		}).start();
	
 }
	
}
Java多线程：写一下两个线程交替打印 0~100 的奇偶数
dadiyang的博客
03-07 1万+
面试场景 面试官：Java多线程了解吗？你给我写一下，起两个线程交替打印0~100的奇偶数。 小黄：啊？ 面试官：就是有两个线程，一个线程打印奇数另一个打印偶数，它们交替输出。类似这样 偶线程：0 奇线程：1 偶线程：2 …… 奇线程：99 偶线程：100 小黄：啊？ 面试官：……嗯。好的。回去等通知吧。 解说 遇到这种突如其来的面试题，有时候会让人无从下手。尽管可能你学习过多线程的知识，但是面...
java两个线程打印奇数和偶数
08-13 4370
设计两个线程类，一个线程类负责打印100以内所有的偶数，另一个线程打印100以内所有的奇数。要求偶数线程每打印10个偶数以后，就让奇数线程打印10个奇数，如此交替进行。 public class TwoThreadPrint { public static void main(String[] args) { PrintBean bean = new PrintB
Java使用多线程实现一个线程输出奇数，另一个线程输出偶数，要求两个线程交替输出
最新发布
m0_74979128的博客
05-03 688
如何实现创建两个线程，然后一个输出奇数，一个输出偶数，而且两个线程得交替输出。
java两个线程交替打印_java两个线程交替打印奇偶数
weixin_33207144的博客
02-12 1000
引言java面试中经常会遇到这个问题，如何用两个线程交替打印奇偶数。线程A打印1，线程B打印2，线程A打印3，线程B打印4...这个问题的解题思路是协调两个线程的执行时机，线程A与线程B需要交替执行。实现的方式很多，常用的方法是采用wait/notify方法。本文记录了笔者解决这个问题的过程，并解释过程中遇到的坑以及如何填坑的，以供朋友们参考。一种有问题的实现方式代码思路是这样的：既然要两个线程交...
java 交替打印AB,JAVA 两个线程交替打印奇偶数
weixin_30739835的博客
03-20 543
涉及到线程间的通信问题，在程序层面来说可以通过线程的等待和唤醒来实现线程之间的通知。先创建奇偶线程类public class OddEvenThread implements Runnable {private volatile int i = 0;private Object lock = new Object();@Overridepublic void run() {for(;;) {syn...
Java两个线程交替打印奇偶数（两种方法对比）
热门推荐
五道口
10-31 1万+
我们将通过“两个线程交替打印100内的奇偶数”，来展示下`wait()`方法和`notify()`方法的用法和优点，当然要体现出优点，自然要通过对比不使用这两个方法实现同一功能的代码，通过这几篇文章的讲解，帮你彻底搞懂`wait()`方法和`notify()`方法的用法。
Java 实现多线程切换等待唤醒交替打印奇偶数
08-25
在这个实例中，我们使用 AtomicInteger 来记录奇偶数，我们使用两个线程 A 和 B 来交替打印奇偶数。我们使用 synchronized 关键字来实现线程的同步，我们使用 wait() 和 notify() 方法来实现线程之间的等待和唤醒。 ...
Java多线程交替输出奇数和偶数
abe_abd的博客
07-25 932
Java多线程 wait/notify/notifyAll
面试必问！Java 多线程中两个线程交替执行，一个输出偶数，一个输出奇数
ignore
05-26 2631
前言 楼主今天在面经上看到这个题，挺有意思，小小的题目对多线程的考量还挺多。大部分同学都会使用 synchronized 来实现。楼主今天带来另外两种优化实现，让你面试的时候，傲视群雄！ 第一种 synchronized class ThreadPrintDemo2 { public static void main(String[] args) { final Thre...
java线程编程面试题轮流打印,经典面试题——两个线程交替打印奇数和偶数，...
weixin_30155853的博客
03-16 397
经典面试题——两个线程交替打印奇数和偶数，前提今天下班时候和同事聊天偶然听到面试题“两个线程交替打印奇数和偶数”的实现，这里做一个复盘。复盘场景一：线程A打印奇数，线程B打印偶数，线程A和线程B交替打印，使用对象监视器实现。场景二：线程A打印奇数，线程B打印偶数，线程A和线程B交替打印，使用JDK提供的并发类库实现。这两个场景中，场景一是一种比较古老的同步方式，本质由JVM实现；场景二是JDK1....
两个线程交替打印奇数和偶数
赶路人儿
09-24 573
实现思路是使用锁来控制不同线程的执行。下面有两种实现： 1、使用对象监视器： public class OddEvenPrinter { private final Object monitor = new Object(); private final int limit; private volatile int count; public OddEvenPrinter(int limit, int initCount) { this.limit
Java-两个线程交替打印奇数和偶数(1-100)
一名Java开发者的博客
03-24 451
两个线程交替打印奇数和偶数, 本文使用synchronized锁来实现交替打印, 并且使用Object类中的 notify() 方法来唤醒其他等待当前对象监视器的线程, 使用Object类的 wait() 方法使当前线程进入等待状态, 避免同一个线程一直自旋抢占。
Java两个线程交替打印奇数和偶数
华安小书童的博客
02-21 835
今天看到这个面试题后满脑子想的都是必须得用加锁，通信才可以完成的。发现走了不少弯路。直接上代码，面试用。 package com.macro.mall.demo.test.thread.productconsumer; import java.util.concurrent.atomic.AtomicInteger; /** * @author zxw * @version 1.0 * ...
java 2个线程交替打印奇偶数
tiantangpw的专栏
12-25 256
/** * java 2个线程交替打印奇偶数 * @author Administrator * */ public class Main { public static void main(String[] args) { Print p=new Print(); Thread a=new Thread(p,"A");//A打印偶数 ...
Java两个线程交替打印奇偶数
灵颖桥人的博客
04-02 1034
思路：利用Object.wait()和Object.notify()方法进行线程间的通信。 代码： public class MyThread implements Runnable { private static int i = 1; private byte[] s1; public MyThread(byte[] s1) { this.s...
Java实现两个线程交替打印奇偶数
sjhuangx的专栏
05-14 836
使用两个线程分别交替打印奇偶数。 实现思路，通过一个对象锁同步请求，获取锁之后判断当前数字时候为奇数或者偶数，然后使用Object.wait方法释放锁并等待。 public class Main { public static void main(String[] args) { Main main = new Main(); main.test(); } private volatile int count = 0; pu.
【算法】两个线程 交替打印奇偶数 （java实现）
kangbin825的专栏
11-28 3562
package com.billkang.algorithm; /** * 两个线程 交替打印奇偶数 * * @author Kangbin * @date 2018-11-28 */ public class OddEven { public static class Num { int i = 1; /** * 线程交...
java奇偶数循环_java两线程交替打印奇偶数
weixin_33313117的博客
02-26 214
public classOddEven {intlen;int[] num;int idx = 0;final Boolean lock = false;ReentrantLock rlock= newReentrantLock();public OddEven(intlen) {this.len =len;num= new int[len];for (int i = 0; i < len;...
Java并发编程：两个线程交替打印0-100的奇偶数
何哥的博客
09-16 4117
问题描述：两个线程交替打印输出数字，一个线程只打印偶数，另一个只打印奇数 方案一：使用synchronized关键字 创建两个线程，一个线程处理偶数，一个线程处理奇数，两个线程之间通过synchronized进行同步，保证count++每次只有一个线程进行操作 为什么两个线程能交替执行，这里很巧的是count从0123...自增过程就是一个奇偶数交替的过程，实际上两个线程都是在不停的尝试（while循环）进入synchronized代码块，如果满足相对应的条件（偶数或是奇数）就打印输出。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值