【java多线程】线程间通信-利用wait和notify轮流按序打印奇数和偶数

于 2025-05-18 22:45:54 发布
阅读量449 收藏 3
点赞数 5
CC 4.0 BY-SA版权
分类专栏： java多线程 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lichuangcsdn/article/details/148051251

线程之间通信，可以用wait和notify来实现。

（一）对wait的理解

wait是object的一个方法，表示是当前执行代码的线程进行等待，且会释放当前的锁，满足一定条件时被唤醒，然后重新尝试获取锁。这样说明，必须先持有锁，才能执行wait语句，所以wait一般是用在synchronized代码块中。

wait如果需要结束等待，可以通过其他线程调用该对象的notify方法，也可以在wait时设置等待超时时间，或者通过其他线程调用等待线程的interrupt方法，导致wait抛出interruptedException异常

（二）对notify的理解

notify是唤醒等待的线程，notify用来唤醒那些等待当前对象持有的锁的其他线程。如果只需要唤醒1个等待的线程，直接用notify即可。如果需要从多个等待的线程中，随机唤醒1个，则需要用notifyAll，同样的notify也需要在synchronized同步代码块中使用到

（三）下面我们通过一个例子来说明wait和notify的使用，并讲述线程间是如何通信的。这个例子的代码如下，这个例子实现了用多线程轮流按序来打印奇数和偶数。

package com.company;

public class JishuAndOuShuTest {
    public static void main(String[] args) {
        Data data = new Data();
        //线程数量
        int THREAD_COUNT = 3;
        Thread[] threadJiShuArray = new Thread[THREAD_COUNT];
        Thread[] threadOuShuArray = new Thread[THREAD_COUNT];

        //初始化奇数线程和偶数线程
        for (int i = 0; i < THREAD_COUNT; i++) {
            //奇数打印线程数组
            threadJiShuArray[i] = new Thread(() -> {
                while (data.getCount() <= 100) {
                    data.printJiShu();
                }
            }, "奇数线程" + i);

            //偶数打印线程数组
            threadOuShuArray[i] = new Thread(() -> {
                while (data.getCount() <= 100) {
                    data.printOuShu();
                }
            }, "偶数线程" + i);
        }

        //启动奇数线程和偶数线程
        for (int i = 0; i < THREAD_COUNT; i++) {
            threadJiShuArray[i].start();
            threadOuShuArray[i].start();
        }
    }
}

class Data {

    /**
     * 需要打印的数据
     */
    private int count = 1;

    public synchronized int getCount() {
        return count;
    }

    /**
     * 打印奇数
     */
    public synchronized void printJiShu() {
        if (count % 2 == 1) {
            System.out.println(Thread.currentThread().getName() + "打印" + count);
            count++;
            this.notifyAll();
        } else {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 打印偶数
     */
    public synchronized void printOuShu() {
        if (count % 2 == 0) {
            System.out.println(Thread.currentThread().getName() + "打印" + count);
            count++;
            this.notifyAll();
        } else {
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

运行结果如下：

奇数线程0打印1
偶数线程0打印2
奇数线程0打印3
偶数线程0打印4
奇数线程0打印5
偶数线程0打印6
奇数线程1打印7
偶数线程0打印8
奇数线程0打印9
偶数线程1打印10
奇数线程1打印11
偶数线程0打印12
奇数线程2打印13
偶数线程1打印14
奇数线程1打印15
偶数线程2打印16
奇数线程2打印17
偶数线程1打印18
奇数线程1打印19
偶数线程2打印20
奇数线程2打印21
偶数线程1打印22
奇数线程1打印23
偶数线程2打印24
奇数线程2打印25
偶数线程1打印26
奇数线程1打印27
偶数线程2打印28
奇数线程2打印29
偶数线程1打印30
奇数线程1打印31
偶数线程2打印32
奇数线程2打印33
偶数线程1打印34
奇数线程1打印35
偶数线程2打印36
奇数线程2打印37
偶数线程1打印38
奇数线程1打印39
偶数线程2打印40
奇数线程2打印41
偶数线程1打印42
奇数线程1打印43
偶数线程2打印44
奇数线程2打印45
偶数线程1打印46
奇数线程1打印47
偶数线程2打印48
奇数线程2打印49
偶数线程1打印50
奇数线程1打印51
偶数线程2打印52
奇数线程2打印53
偶数线程1打印54
奇数线程0打印55
偶数线程2打印56
奇数线程1打印57
偶数线程1打印58
奇数线程0打印59
偶数线程2打印60
奇数线程1打印61
偶数线程1打印62
奇数线程0打印63
偶数线程2打印64
奇数线程1打印65
偶数线程1打印66
奇数线程0打印67
偶数线程2打印68
奇数线程1打印69
偶数线程1打印70
奇数线程0打印71
偶数线程2打印72
奇数线程1打印73
偶数线程1打印74
奇数线程0打印75
偶数线程2打印76
奇数线程1打印77
偶数线程1打印78
奇数线程0打印79
偶数线程2打印80
奇数线程1打印81
偶数线程1打印82
奇数线程0打印83
偶数线程2打印84
奇数线程1打印85
偶数线程1打印86
奇数线程0打印87
偶数线程2打印88
奇数线程1打印89
偶数线程1打印90
奇数线程0打印91
偶数线程2打印92
奇数线程1打印93
偶数线程1打印94
奇数线程0打印95
偶数线程2打印96
奇数线程1打印97
偶数线程1打印98
奇数线程0打印99
偶数线程2打印100
Disconnected from the target VM, address: '127.0.0.1:61821', transport: 'socket'

Process finished with exit code 0

在上面代码中，我们能看到wait和notifyAll是用在synchronized同步方法中，我们设置了3个奇数打印线程和3个偶数打印线程，来轮流交替打印1-100之间的奇数和偶数。

代码运行流程如下：

首先会判断当前数是否小于100，如果小于100，则奇数线程和偶数线程都会开始运行。当奇数线程运行时，在printJiShu同步方法中，会判断当前数据是否为奇数，如果是奇数，则会打印出来，并且再自增1，因为数据就变成了偶数，然后当前线程就通过notify唤醒其他线程，然后此时数据还是小于100，奇数线程会再次执行while语句中的代码块，因为当前数据是偶数了，会走else分支，然后当前线程通过wait方法，进入等待状态。而偶数线程的执行过程也类似，当判断当前数字小于100，偶数线程会开始运行，然后判断当前数字是否为偶数，如果是偶数，则会打印出来，并执行自增1的操作，然后又会唤醒其他出于wait的线程。此时可能唤醒奇数线程，如果奇数线程被唤醒，因为次数数字又变成了奇数，然后又会执行奇数打印，然后再自增1，之后再进行唤醒其他线程，如此循环。直至打印的数字变成100，然后跳出while循环，从而线程执行结束。

Java多线程轮流打印奇数和偶数
DevProZ的博客
09-19 308
类似于OddPrinter，EvenPrinter类的构造函数接受一个锁对象和要打印的最大偶数。当我们运行这段代码时，OddPrinter线程将打印从1到10之间的奇数，EvenPrinter线程将打印从2到10之间的偶数。在Main类的main方法中，我们创建了一个共享的锁对象和一个表示最大数字的变量。然后，我们创建了一个OddPrinter线程和一个EvenPrinter线程，并将它们启动。通过合理地使用锁对象和线程间的等待和通知机制，我们可以实现线程之间的协作，以达到预期的结果。
java多线程 两个线程交叉打印1到100的数字
许诗宇的博客
02-18 3585
目录 解法1 静态原子变量 死循环 解法2 静态变量 死循环/wait 锁住class 解法3 静态变量ReentrantLockCondition 扩展问题 注意：本文参考面试题精选:两个线程按顺序交替输出1-100 - xindoo - 博客园 具体题目是这样的，两个线程交替按顺序输出1-100，第一个线程只能输出偶数，第二线程输出奇数，想象下两个小孩轮流喊数。 两个线程交替输出，这就意味着它俩是需要协同的，协同意味着二者之间要有信息传递，如何相互传递信息？ 你可能直接想到，既...
Java多线程编程—wait/notify机制
qq_43456605的博客
04-08 1120
wait/notify 多线程 消费者生产者模式
【Java多线程编程】wait与notify方法详解
我的主页
05-18 4212
本期讲解：Java 多线程中的 wait方法、notify方法、notifyAll方法，wait方法与sleep方法之间的区别。
Java 多线程的wait,notify,notifyAll,sleep,interrupt方法
TGO-Ming
03-27 1192
wait()、notify()和notifyAll()这三个方法都依赖于Java对象的监视器锁（也称为内置锁或互斥锁）。调用这些方法时，当前线程必须持有该对象的监视器锁，所以通常它们三都与synchronized 关键字一起使用，否则将抛出IllegalMonitorStateException异常(也就是没有获取对象的监视器锁和调用了这些方法)。
Java多线程——信号量Semaphore是啥
Arya的博客，专注后端领域
03-05 1111
Java多线程——信号量Semaphore是啥。
多线程交替输出奇数偶数1到1000（wait/notify）
m0_60424152的博客
03-11 283
类似，可先参考，解析稍后补充！
两个线程交替打印1-100的奇数和偶数
bobo1356的博客
12-05 8235
问题定义 启动a、b两个线程，由这两个线程打印出1到100共一百个数字。 要求： a线程打印1、3、5、7等奇数，b线程打印2、4、6、8等偶数。 依次串行打印，即打印完1之后，再打印2，然后是3、4、5…直到100，全部打印完成后，进程能正常结束。 解决思路 两个线程交替打印，就是要两个线程之间进行同步，走走停停。线程的同步可以使用Object类自带的wait和notify（或者notify...
C++11用两个线程轮流打印整数的实现方法
12-16
本文将详细解析如何使用C++11的标准线程语法来实现两个线程轮流打印整数，其中一个线程打印奇数，另一个线程打印偶数，同时涉及到线程同步的关键技术——互斥量和条件变量。 首先，为了确保线程安全，我们需要使用...
C++ 实现两个线程交替打印奇偶数
weixin_43256077的博客
07-21 327
【代码】C++ 实现两个线程交替打印奇偶数。
[Java 多线程技术]（七）使用wait/notify实现线程间通信
YHJ
06-10 2202
线程是操作系统中独立的个体，但这些个体如果不经过特殊处理就不能成为一个整体。线程间的通信就是成为整体的必用方案之一，可以说，使线程间进行通信后，系统之间的交互性会更加强大，在大大提高CPU利用率的同时还会使程序员对各线程任务在处理的过程中进行有效的把控和监督。 1. 等待通知机制 1.1 不使用等待/通知机制实现线程间通信 　　创建新项目，在实验中使用sleep()结合while(true)死循环法来实现多个线程间通信。代码如下： public class MyList { priva.
Java中多线程wait和notify的用法
qq_63218110的博客
01-19 2611
本篇文章主要介绍wait和notify的使用，大家可能感到疑惑的问题：比如wait和notify为什么需要加锁？wait和sleep的区别等。
java线程学习(四)：线程等待wait()和通知notify()的详细使用
shenhaiyushitiaoyu的博客
12-17 7224
线程等待wait()和通知notify()，主要用于多线程之间的协作，而且这两个方法都是属于Object类，说明任何对象都可以调用这两个方法。 当在一个对象实例上调用wait()方法后，当前线程就会在这个对象上等待。直到另外的线程调用了notify()方法，出于等待的线程才得以继续进行。这样，多线程之间的协作就可以用这两个方法进行通信了。 先看下例子： package stop_demo; pu...
Java多线程notify/notifyAll唤醒的是谁
nO0b
11-28 9512
涉及JAVA线程的状态问题, 不清楚的可以参考我的另一篇: https://blog.youkuaiyun.com/q5706503/article/details/84350887 我们知道notify是Object的本地final方法，无法被重写, 用来唤醒线程, 那么该怎么用, 唤醒的又是谁呢? 用一句话做答复 : notify唤醒的是其所在锁所阻塞的线程 不理解看下面的分析和例子: wait...
JAVA多线程基础篇-线程通信(wait/notify)
qq_33479841的博客
07-10 2134
在JAVA多线程中，线程通信是重要概念之一。线程通信能够使系统之间的交互性更强大，在大大提高CPU利用率的同时还会使程序员对各线程在任务处理过程中进行有效把控。本文将针对使用wait/notify进行线程之间通信进行分析，详述其实现过程、原理以及相关注意事项。.........
Java多线程-notify与notifyAll的区别？
D_honor的博客
08-30 579
要明白notify与notifyAll的区别，首先我们来谈一下锁池与等待池的概念： 下面我们来谈谈两者的区别： notifyAll会让所有处于等待池的线程全部进入锁池去竞争获取锁的机会 notify 指挥随机选取一个处于等待池中的线程进入锁池去竞争获取所得机会 ...
java多线程notify_java 多线程 线程之间的协作 notify()和notifyAll()
weixin_42169245的博客
03-08 437
使用notify()而不是notifyAll()是一种优化。使用notify()时，在众多等待同一个锁的任务中只有一个会被唤醒，因此如果你希望使用notify()，就必须保证被唤醒的是恰当的任务。另外，为了使用notify()，所有任务必须等待相同的条件，因为如果你有多个任务在等待不同的条件，那么你就不会知道是否唤醒了恰当的任务。如果使用notify()，当条件发生变化时，必须只有一个任务能够从中...
Java多线程中wait, notify and notifyAll的使用
热门推荐
阳光日志
06-27 2万+
在Java的Object类中有三个final的方法允许线程之间进行资源对象锁的通信，他们分别是： wait(), notify() and notifyAll()。 调用这些方法的当前线程必须拥有此对象监视器，否则将会报java.lang.IllegalMonitorStateException exception异常。
如何实现两个线程交替打印
最新发布
04-01
<think>好的，我现在需要帮助用户了解如何通过编程实现两个线程交替打印。用户已经提供了一些参考资料，包括使用Java和Python的例子，以及涉及synchronized、wait、notify等方法。我需要先整理这些信息，然后给出清晰的步骤和示例代码。 首先，用户的问题是关于两个线程交替打印的实现方法，可能是指交替打印奇偶数，或者交替打印不同的字符。根据提供的引用，常见的做法是使用线程间的同步机制，比如锁和条件变量，或者使用wait/notify来控制线程的执行顺序。 我需要考虑不同编程语言的实现，用户提供的引用中有Java和Python的例子。但用户的问题没有指定语言，可能需要给出两种语言的示例，或者选择其中一种。不过用户之前的问题可能偏向Python，因为最后的示例代码是Python的快速排序，但引用的资料中有Java和Python的例子。需要确认用户的需求，但根据问题描述，用户可能希望得到通用的方法，或者具体语言的示例。 另外，用户提到“交替打印”，可能是指两个线程轮流执行，比如一个打印奇数，一个打印偶数，或者交替打印A和B。需要明确场景，但根据引用中的例子，奇偶数交替打印比较常见。 接下来，我需要整理实现步骤。通常，实现线程交替打印需要以下步骤： 1. 创建共享对象或锁，用于线程同步。 2. 定义两个线程，每个线程负责打印特定的内容。 3. 使用同步机制确保每次只有一个线程执行打印操作。 4. 通过wait和notify（或类似机制）控制线程的交替执行。 在Java中，可以使用synchronized关键字配合wait和notify，或者使用ReentrantLock和Condition。在Python中，由于GIL的存在，多线程可能不如多进程高效，但可以使用threading模块中的Lock和Condition来实现。 需要检查引用中的示例，例如引用[1]和[4]提到Java中使用synchronized和wait/notify，而引用[2]和[5]提到Python中的多线程交替打印。引用[3]提到使用Condition对象。 现在，我需要为两种语言分别给出示例代码，并解释其步骤。但用户可能希望得到一个具体的例子，比如交替打印奇偶数，或者交替打印ABAB等。 根据用户的问题，他们可能希望看到两种方法的对比，比如使用synchronized和wait/notify的方法，或者使用Lock和Condition的方法。需要参考提供的引用，例如引用[4]中的实现方式，以及引用[3]中的Condition用法。 在Java中，基本的实现步骤是： - 共享一个锁对象。 - 线程1获取锁后，检查条件是否满足（如是否是偶数），满足则打印并递增，然后唤醒另一个线程，否则等待。 - 线程2类似，检查是否是奇数，打印后唤醒另一个线程。 在Python中，由于没有内置的wait/notify机制，可以使用threading.Condition来实现类似的功能。或者使用Event对象。 需要注意的是，在Python中，多线程由于GIL的关系，可能不会真正并行执行，但交替打印可以通过同步机制实现。 另外，需要考虑线程启动的顺序，可能需要一个标志变量来确定当前应该由哪个线程执行。 现在，需要编写示例代码。例如，在Java中，使用synchronized的代码可能如下： class Shared { int count = 1; boolean isOdd = true; } 线程1（奇数线程）： synchronized (shared) { while (shared.count <= max) { if (shared.isOdd) { print; shared.count++; shared.isOdd = false; shared.notify(); } else { shared.wait(); } } } 线程2（偶数线程）类似，检查isOdd是否为false。 在Python中，可以使用threading.Condition： import threading class Shared: def __init__(self): self.count = 1 self.cond = threading.Condition() self.is_odd = True def print_odd(shared, max): with shared.cond: while shared.count <= max: if shared.is_odd: print(shared.count) shared.count +=1 shared.is_odd = False shared.cond.notify() else: shared.cond.wait() def print_even(shared, max): with shared.cond: while shared.count <= max: if not shared.is_odd: print(shared.count) shared.count +=1 shared.is_odd = True shared.cond.notify() else: shared.cond.wait() 然后创建两个线程，启动它们。 不过需要确保线程正确退出，否则可能出现无法结束的情况，如引用[5]中提到的问题，可能需要检查条件是否满足，并在适当的时候退出循环。 还需要考虑最大次数，比如打印到10为止。 另外，在Python中，由于线程可能因为wait而阻塞，需要确保在count超过max时，线程能够退出循环。 例如，在print_odd函数中： while shared.count <= max: if ...: ... else: shared.cond.wait() 但如果在等待时，count已经超过max，线程可能无法退出。因此，可能需要使用带有超时的wait，或者在notify时确保所有线程都能被唤醒。或者，在循环条件中不仅要检查count是否超过max，还要处理被唤醒后的状态。 这可能需要更复杂的条件判断。 另外，在Java中，使用两个Condition对象可能更高效，如引用[3]提到的，每个线程有自己的Condition，这样在唤醒时只唤醒另一个线程，而不是所有等待的线程，避免虚假唤醒。 综上，我需要整理出两种实现方法：使用synchronized和wait/notify，以及使用Lock和Condition（可能更高效）。然后给出Java和Python的示例代码，并解释每个步骤。 在回答中，需要结构清晰，分步骤说明，并确保代码正确，避免死锁或无法退出的情况。同时，需要引用提供的参考资料，例如引用[1]、[3]、[4]中的方法。</think>### 两个线程交替打印的实现方法 实现两个线程交替打印的核心在于**线程同步**和**条件判断**。以下是两种常见实现方式的详细步骤及示例代码： --- ### 方法一：使用`synchronized`和`wait/notify`（Java） 通过共享对象的锁机制，控制线程交替执行。 #### 实现步骤： 1. **定义共享对象**：存储当前打印的数值和线程状态。 2. **线程1打印奇数**：检查当前数值是否为奇数，满足则打印并唤醒线程2，否则等待。 3. **线程2打印偶数**：检查当前数值是否为偶数，满足则打印并唤醒线程1，否则等待。 ```java public class AlternatePrint { private static final Object lock = new Object(); private static int count = 1; private static final int MAX = 10; public static void main(String[] args) { new Thread(() -> { synchronized (lock) { while (count <= MAX) { if (count % 2 == 1) { System.out.println("Thread 1: " + count++); lock.notify(); // 唤醒线程2 } else { try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } }).start(); new Thread(() -> { synchronized (lock) { while (count <= MAX) { if (count % 2 == 0) { System.out.println("Thread 2: " + count++); lock.notify(); // 唤醒线程1 } else { try { lock.wait(); } catch (InterruptedException e) { e.printStackTrace(); } } } } }).start(); } } ``` **关键点**： - `wait()`释放锁并进入等待状态，`notify()`唤醒其他线程[^4]。 - 必须使用循环检查条件，避免虚假唤醒[^5]。 --- ### 方法二：使用`Condition`和`ReentrantLock`（Java） 通过更细粒度的锁控制，减少不必要的唤醒。 #### 实现步骤： 1. **定义锁和条件变量**：每个线程关联一个`Condition`。 2. **交替触发条件**：奇数线程完成后触发偶数线程的条件，反之亦然。 ```java import java.util.concurrent.locks.*; public class AlternatePrintWithCondition { private static ReentrantLock lock = new ReentrantLock(); private static Condition oddCondition = lock.newCondition(); private static Condition evenCondition = lock.newCondition(); private static int count = 1; private static final int MAX = 10; public static void main(String[] args) { new Thread(() -> { lock.lock(); try { while (count <= MAX) { if (count % 2 == 1) { System.out.println("Thread 1: " + count++); evenCondition.signal(); // 通知偶数线程 } else { oddCondition.await(); } } } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } }).start(); new Thread(() -> { lock.lock(); try { while (count <= MAX) { if (count % 2 == 0) { System.out.println("Thread 2: " + count++); oddCondition.signal(); // 通知奇数线程 } else { evenCondition.await(); } } } catch (InterruptedException e) { e.printStackTrace(); } finally { lock.unlock(); } }).start(); } } ``` **关键点**： - 每个线程通过`Condition.await()`等待，通过`Condition.signal()`精准唤醒目标线程[^3]。 - 避免全局锁竞争，提升效率。 --- ### 方法三：使用`threading.Condition`（Python） Python中通过条件变量实现类似逻辑。 ```python import threading class SharedState: def __init__(self): self.count = 1 self.cond = threading.Condition() self.is_odd = True def print_odd(shared, max_count): with shared.cond: while shared.count <= max_count: if shared.is_odd: print(f"Thread 1: {shared.count}") shared.count += 1 shared.is_odd = False shared.cond.notify() else: shared.cond.wait() def print_even(shared, max_count): with shared.cond: while shared.count <= max_count: if not shared.is_odd: print(f"Thread 2: {shared.count}") shared.count += 1 shared.is_odd = True shared.cond.notify() else: shared.cond.wait() shared = SharedState() max_num = 10 t1 = threading.Thread(target=print_odd, args=(shared, max_num)) t2 = threading.Thread(target=print_even, args=(shared, max_num)) t1.start() t2.start() t1.join() t2.join() ``` **关键点**： - `with shared.cond`自动获取和释放锁。 - `notify()`唤醒等待的线程，`wait()`释放锁并阻塞[^2]。 --- ### 对比分析 | 方法 | 优点 | 缺点 | |----------------|-------------------------------|------------------------------| | `synchronized` | 代码简单，无需额外依赖 | 唤醒不精准，可能产生竞争 | | `Condition` | 精准唤醒，减少锁竞争 | 代码复杂度稍高 | | Python实现 | 语法简洁，适合轻量级任务 | 因GIL限制，不适合CPU密集型任务 | ---
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值