异常教程

Java Object wait(long timeout) 方法（建议收藏）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战(已更新的所有项目都能学习) / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

  • 新开坑项目:《Spring AI 项目实战》 正在持续爆肝中，基于 Spring AI + Spring Boot 3.x + JDK 21...， 点击查看 ;
  • 《从零手撸：仿小红书（微服务架构）》 已完结，基于 Spring Cloud Alibaba + Spring Boot 3.x + JDK 17...，点击查看项目介绍 ;演示链接： http://116.62.199.48:7070 ;
  • 《从零手撸：前后端分离博客项目（全栈开发）》 2 期已完结，演示链接： http://116.62.199.48/ ;

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

在 Java 多线程编程中，线程间的协作与通信是实现复杂功能的核心能力之一。Object wait(long timeout) 方法作为 Java 提供的线程同步工具，能够帮助开发者控制线程的执行流程。无论是构建生产者-消费者模型、同步屏障，还是处理资源竞争问题，这一方法都扮演着关键角色。然而，由于其使用场景和规则较为复杂，许多开发者在初次接触时容易产生困惑。本文将从基础概念出发，结合实例与类比，深入解析 Java Object wait(long timeout) 方法 的原理与应用。

一、理解线程同步与等待机制

1.1 线程同步的核心问题

多线程环境下，多个线程可能同时访问共享资源，导致数据不一致或竞争条件。为解决这一问题，Java 提供了 synchronized 关键字、wait/notify/notifyAll 方法等工具。其中，wait 方法的作用是让当前线程进入“等待状态”，并将锁释放，直到其他线程通过 notify 或 notifyAll 唤醒，或等待时间到达指定超时值。

1.2 等待/通知模型的类比

想象一个办公室的场景：

  • 线程如同办公室的员工。
  • 锁（Monitor） 是一把仅能由一名员工持有的钥匙，用于控制对共享资源（如打印机）的访问。
  • wait() 相当于员工暂时放下钥匙，离开工作区休息。
  • notify() 是有人轻拍休息中的员工肩膀，提醒他们回来继续工作。

通过这种类比，可以直观理解 wait 和 notify 的协作关系。

二、wait(long timeout) 方法的语法与参数

2.1 方法定义

public final void wait(long timeout) throws InterruptedException

此方法声明在 java.lang.Object 类中，必须在同步代码块或方法内调用。其参数 timeout 是线程等待的最大毫秒数。

2.2 参数与行为解析

参数说明
timeout等待时间限制（单位：毫秒）。若为 0，则线程无限期等待，直到被 notify 唤醒。

2.3 关键特性

  • 释放锁：调用 wait() 会释放当前线程持有的对象锁。
  • 唤醒条件：线程可能因以下原因恢复执行：
    1. 其他线程调用 notify() 或 notifyAll()。
    2. 等待时间超过 timeout。
    3. 被中断（此时会抛出 InterruptedException）。

三、使用 wait(long timeout) 的典型场景

3.1 生产者-消费者模型

在生产者-消费者模型中，生产者生成数据放入缓冲区，消费者从缓冲区取出数据。若缓冲区已满，生产者需等待；若缓冲区为空，消费者需等待。通过 wait(timeout) 可实现超时机制，避免无限期阻塞。

示例代码（简化版）

class Buffer {  
    private int count = 0;  
    private static final int CAPACITY = 5;  

    public synchronized void produce() throws InterruptedException {  
        while (count >= CAPACITY) {  
            // 缓冲区已满，等待最多 1 秒  
            wait(1000);  
        }  
        count++;  
        System.out.println("Produced: " + count);  
        notify(); // 唤醒消费者  
    }  

    public synchronized void consume() throws InterruptedException {  
        while (count <= 0) {  
            // 缓冲区已空，等待最多 1 秒  
            wait(1000);  
        }  
        count--;  
        System.out.println("Consumed: " + count);  
        notify(); // 唤醒生产者  
    }  
}  

// 测试代码  
Buffer buffer = new Buffer();  
new Thread(() -> {  
    try {  
        while (true) {  
            buffer.produce();  
            Thread.sleep(500);  
        }  
    } catch (InterruptedException e) {  
        e.printStackTrace();  
    }  
}).start();  

new Thread(() -> {  
    try {  
        while (true) {  
            buffer.consume();  
            Thread.sleep(800);  
        }  
    } catch (InterruptedException e) {  
        e.printStackTrace();  
    }  
}).start();

3.2 超时机制的实践意义

在上述代码中，若生产者连续 wait(1000) 但未被唤醒，1 秒后会自动恢复执行。这避免了因消费者未及时唤醒导致的死锁风险，尤其适用于网络请求超时或外部资源不可用的场景。

四、常见错误与注意事项

4.1 必须在同步上下文中调用

若未在 synchronized 块中调用 wait()，将抛出 IllegalMonitorStateException。例如：

// 错误示例  
public void wrongUsage() {  
    this.wait(1000); // 未持有对象锁，会抛出异常  
}

4.2 timeout 的精度问题

timeout 是最大等待时间，但实际等待时间可能略长于指定值，因线程调度存在延迟。

4.3 与 notify() 的配合

  • notify()：随机唤醒一个等待线程。
  • notifyAll()：唤醒所有等待线程。
    若需确保所有线程都能响应，应使用 notifyAll()，但需注意竞争条件。

4.4 超时后的逻辑处理

线程因超时恢复后，需重新检查条件是否满足。例如：

synchronized (obj) {  
    while (!condition) {  
        obj.wait(1000); // 等待 1 秒  
    }  
    // 条件满足后继续执行  
}

此处的 while 循环而非 if 判断，是为了避免“虚假唤醒”（由 JVM 实现细节或中断导致的意外唤醒）。

五、对比其他等待方法

5.1 wait() 与 wait(long timeout)

方法是否超时适用场景
wait()无超时等待明确的唤醒信号
wait(long timeout)支持超时需要限制等待时间或处理超时逻辑

5.2 与 Thread.sleep() 的区别

  • sleep()：
    • 不释放锁，属于线程自身休眠。
    • 需配合 synchronized 使用时，不会影响其他线程对锁的获取。
  • wait()：
    • 释放锁，允许其他线程进入同步代码块。
    • 必须在同步块内调用。

示例对比

// 使用 Thread.sleep()  
synchronized (lock) {  
    Thread.sleep(1000); // 持有锁，其他线程无法进入  
}  

// 使用 Object.wait()  
synchronized (lock) {  
    lock.wait(1000); // 释放锁，其他线程可进入  
}

六、高级应用场景：超时后的资源回收

6.1 网络请求的超时控制

在模拟 HTTP 请求时，若服务端未在指定时间内响应，客户端可终止等待并释放资源：

synchronized (requestLock) {  
    if (!requestLock.wait(5000)) { // 等待 5 秒  
        System.out.println("Request timed out. Closing connection.");  
        // 执行资源清理  
    } else {  
        // 处理响应  
    }  
}

6.2 定时任务的协调

在定时任务调度系统中，任务执行线程可在 wait() 中等待，直到被 notify() 触发或超时后自动执行：

public class TaskScheduler {  
    private final Object schedulerLock = new Object();  
    private boolean isRunning = true;  

    public void scheduleTask(Runnable task, long delay) {  
        synchronized (schedulerLock) {  
            try {  
                schedulerLock.wait(delay); // 等待指定时间  
                task.run();  
            } catch (InterruptedException e) {  
                Thread.currentThread().interrupt();  
            }  
        }  
    }  
}

七、总结与实践建议

Java Object wait(long timeout) 方法 是多线程编程中不可或缺的工具，其核心作用在于通过释放锁实现线程间的高效协作。开发者需注意以下关键点：

  1. 正确使用同步块：确保 wait() 在 synchronized 上下文中调用。
  2. 超时逻辑设计：结合业务需求合理设置 timeout，避免无限期等待。
  3. 循环条件检查：在 wait() 后通过 while 循环验证条件，防止虚假唤醒。

通过本文的案例与解析，读者可逐步掌握该方法的原理与应用，进而解决实际开发中的线程同步问题。建议读者在真实项目中尝试实现生产者-消费者模型或定时任务调度器，以巩固对 wait/notify 机制的理解。

最新发布

查看更多文章