JAVA中的Wait() 和notify()方法

本文介绍Java多线程编程中如何使用wait与notify方法优化同步代码块,通过实例展示如何控制线程间的协作,提高并发效率。

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

  在java多线程编程中,最被经常用到的便是wait与notfiy方法,这两个方法可以用来更加精确地控制被同步的代码,从而使得被同步的代码最小化,提高并发效率。 
   当某个类的某个方法被标记为synchronized时,这个方法在同一时间只能被一个线程访问。此时这个方法中的所有代码都是被同步的,只有当一个线程执行完所有的代码之后,下一个线程才能开始执行。当被同步的方法代码量比较小,而且每一步执行都非常快的时候仅仅使用synchronized关键字就够了。但是,如果被同步的方法里面有一些代码是可以被共享的,而且这些能够被共享的代码里面存在比较耗时的操作时,仅仅使用synchronized关键字就无法达到最高的效率,这个时候可以使用wait与notify方法来对并发访问做更进一步的控制。首先看两段代码: 
Java代码  收藏代码
  1. public class TestThread {  
  2.     private boolean isIdle = true;  
  3.       
  4.     public synchronized void work(){  
  5.         /* 
  6.          * Some work which can be shared 
  7.          */  
  8.         try {  
  9.             /* 
  10.              * to check if we can have this object's monitor 
  11.              */  
  12.             if(!isIdle){  
  13.                 System.out.println(Thread.currentThread().toString() + ":I'm waiting....");  
  14.             }  
  15.             while(!isIdle){  
  16.                 wait();  
  17.             }  
  18.               
  19.             /* 
  20.              * to set isIdle to false, I'm working.... 
  21.              */  
  22.             this.isIdle = false;  
  23.             System.out.println(Thread.currentThread().toString() + ":I'm working....");  
  24.             Thread.currentThread().sleep(1000);  
  25.             System.out.println(Thread.currentThread().toString() + ":I'm finished....");  
  26.               
  27.             /* 
  28.              * to notify all other thread which is waiting for this object's monitor 
  29.              */  
  30.             this.isIdle = true;  
  31.             notifyAll();  
  32.         } catch (InterruptedException e) {  
  33.             e.printStackTrace();  
  34.         }  
  35.     }  
  36. }  

   在上面的类中定义了一个方法work,在这个方法中的try块之前可以执行一些可共享的代码,而try块中的代码是不能够被共享的。因此,我们在进入try之后会首先判断标志isIdle是否为true,如果为true就表示当前没有其他线程正在访问,因此当前线程就获得了执行try块中代码的权利。在执行代码前当前线程会将isIdle设置成false,这样当其他线程进入try,之后就会发现isIdle为false,从而进入等待状态。 
   当一个线程执行完try中的代码之后,会将isIdle重新设置为true,同是使用notifyAll方法通知所有等待获得执行try块中代码的权利的线程。 
   下面这个类用来测试上面的TestThread: 
Java代码  收藏代码
  1. public class ThreadTester {  
  2.     private static TestThread tt = new TestThread();  
  3.       
  4.     public static void main(String[] args){  
  5.         for(int i = 0; i < 5; i++){  
  6.             new Thread(new Runnable(){  
  7.                 public void run(){  
  8.                     tt.work();  
  9.                 }  
  10.             }).start();  
  11.         }  
  12.     }  
  13. }  

   这个类在main方法中启动了五个不同的线程来访问TestThread的work方法,从打印的结果中可以看出,每次线程的执行顺序都会有些许的差别。 
日志: 
第一次运行: 
Java代码  收藏代码
  1. Thread[Thread-0,5,main]:I'm working....  
  2. Thread[Thread-0,5,main]:I'm finished....  
  3. Thread[Thread-1,5,main]:I'm working....  
  4. Thread[Thread-1,5,main]:I'm finished....  
  5. Thread[Thread-3,5,main]:I'm working....  
  6. Thread[Thread-3,5,main]:I'm finished....  
  7. Thread[Thread-2,5,main]:I'm working....  
  8. Thread[Thread-2,5,main]:I'm finished....  
  9. Thread[Thread-4,5,main]:I'm working....  
  10. Thread[Thread-4,5,main]:I'm finished....  

第二次运行: 
Java代码  收藏代码
  1. Thread[Thread-0,5,main]:I'm working....  
  2. Thread[Thread-0,5,main]:I'm finished....  
  3. Thread[Thread-2,5,main]:I'm working....  
  4. Thread[Thread-2,5,main]:I'm finished....  
  5. Thread[Thread-1,5,main]:I'm working....  
  6. Thread[Thread-1,5,main]:I'm finished....  
  7. Thread[Thread-4,5,main]:I'm working....  
  8. Thread[Thread-4,5,main]:I'm finished....  
  9. Thread[Thread-3,5,main]:I'm working....  
  10. Thread[Thread-3,5,main]:I'm finished....  
<think>好的,我现在需要帮助用户理解Javawaitnotify方法的正确使用,并提供示例注意事项。首先,我得回顾一下这两个方法的基本概念。根据引用[5],waitnotifynotifyAll都是用于线程间通信的方法,用来协调多个线程的执行顺序。当线程调用对象的wait()方法时,它会释放该对象的锁并进入等待状态,直到其他线程调用同一个对象的notify()notifyAll()来唤醒它。 用户需要示例注意事项,所以我得先构造一个典型的生产者-消费者模型作为例子。比如,一个线程负责生产数据,另一个线程负责消费数据。当缓冲区为空时,消费者线程需要等待,直到生产者线程放入数据后通知消费者。同样,当缓冲区满时,生产者需要等待消费者取出数据后再继续生产。这种模式能很好地展示waitnotify的协作。 接下来,我需要确保示例代码正确,并且符合Java的同步机制。根据引用[2][4],在调用waitnotify时,必须持有对象的锁,也就是在synchronized块内部。否则会抛出IllegalMonitorStateException。因此,在示例中,生产者消费者方法都应该用synchronized修饰,或者在synchronized块内调用waitnotify。 然后,要注意虚假唤醒的问题。引用[5]提到,wait()应该在循环中使用,而不是简单的if判断,因为有时线程可能会被意外唤醒,即使条件尚未满足。所以在代码中,检查条件是否满足的语句应该放在while循环中,而不是if语句,这样可以避免这种情况。 另外,用户可能想知道notifynotifyAll的区别。根据引用[5],notify只会唤醒一个等待线程,而notifyAll会唤醒所有等待的线程,但具体哪个线程能继续执行取决于锁的获取。在生产者-消费者模型中,使用notifyAll更安全,因为可能有多个生产者或消费者线程在等待,这样可以避免线程被永久挂起的情况。 然后,我需要列出使用时的注意事项,比如必须在同步块内调用,使用循环检查条件,避免死锁,以及区分notifynotifyAll的使用场景。此外,还要提到在继承Thread类时,不要使用this作为锁对象,因为可能会有不同的实例,导致无法正确同步。 最后,确保回答结构清晰,分步骤说明,示例代码正确,注意事项全面。同时,根据用户提供的引用内容,正确标注引用来源,比如在解释waitnotify机制时引用[5],在示例部分参考引用[2][4]。 现在需要检查是否有遗漏的部分,比如是否覆盖了所有重要的注意事项,示例是否完整,语法是否正确。例如,在示例中,缓冲区使用LinkedList模拟,容量设为1,这样更容易触发等待条件。生产者消费者分别使用waitnotifyAll来协调。同时,主方法中启动两个线程,并设置消费者线程先启动,以展示等待的情况。 可能还需要解释为什么使用while循环而不是if,以及如何处理可能的异常,比如InterruptedException。在代码中,捕获InterruptedException并恢复中断状态是一个好的做法,保持线程的中断响应能力。 总结起来,整个思考过程需要确保回答准确覆盖用户的问题,结合提供的引用内容,结构清晰,示例正确,注意事项全面,并且符合Java多线程的最佳实践。</think>### Java线程中wait()notify()方法使用详解 #### 一、基本机制 `wait()``notify()`是Java多线程通信的核心方法,用于在**同步代码块内**协调线程执行顺序。当线程调用`wait()`时,会释放对象锁并进入等待状态;调用`notify()`则会唤醒一个等待该对象锁的线程[^5]。 #### 二、标准使用示例(生产者-消费者模型) ```java public class BufferExample { private final LinkedList<Integer> buffer = new LinkedList<>(); private final int CAPACITY = 1; public synchronized void produce() throws InterruptedException { while (buffer.size() == CAPACITY) { System.out.println("缓冲区满,生产者等待"); wait(); // 释放锁并等待 } int value = new Random().nextInt(100); buffer.add(value); System.out.println("生产数据:" + value); notifyAll(); // 唤醒所有等待线程[^2] } public synchronized void consume() throws InterruptedException { while (buffer.isEmpty()) { System.out.println("缓冲区空,消费者等待"); wait(); } int value = buffer.removeFirst(); System.out.println("消费数据:" + value); notifyAll(); } public static void main(String[] args) { BufferExample example = new BufferExample(); // 生产者线程 new Thread(() -> { while (true) { try { example.produce(); Thread.sleep(1000); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } }).start(); // 消费者线程 new Thread(() -> { while (true) { try { example.consume(); Thread.sleep(1500); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } }).start(); } } ``` #### 三、关键注意事项 1. **同步要求** 必须使用`synchronized`获取对象锁后才能调用`wait()/notify()`,否则会抛出`IllegalMonitorStateException`[^4] 2. **条件检查规范** 必须使用`while`循环而非`if`判断条件,防止**虚假唤醒**(spurious wakeup): ```java while (condition) { // 正确写法 wait(); } ``` 3. **唤醒方式选择** - `notify()`:随机唤醒一个等待线程 - `notifyAll()`:唤醒所有等待线程,更推荐使用以避免线程饥饿 4. **锁对象一致性** 所有线程必须使用**同一个对象锁**进行同步,通常建议使用专门的对象而非`this`: ```java private final Object lock = new Object(); public void method() { synchronized(lock) { // 操作代码 } } ``` 5. **中断处理** `wait()`可能抛出`InterruptedException`,需要正确处理中断状态: ```java try { wait(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); // 恢复中断状态 } ``` #### 四、典型应用场景 1. 生产者-消费者模式(如示例所示) 2. 线程池任务调度 3. 多阶段任务协作(如:等待前置任务完成)
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值