Java 中 wait 和 notify 的区别

10 Sept 2024 | 5 分钟阅读

在 Java 中，wait() 和 notify() 是 Object 类提供的两个方法，它们用于线程间的通信和同步。

wait() 方法

wait() 方法是 Java 编程语言中的一个同步方法，它使当前线程放弃对象的锁并进入睡眠状态，直到另一个线程在该对象上调用 notify 或 notifyAll 方法。

wait() 方法有三种形式

1. wait(): 线程将保持在等待状态，直到另一个线程在该对象上调用 notify 或 notifyAll 方法。线程将保持在等待状态，直到另一个线程在该对象上调用 notify 或 notifyAll 方法。

语法

2. wait(long timeout): wait(long timeout) 方法使当前线程放弃对象的锁并睡眠指定的毫秒数。

语法

3. wait(long timeout, int nanoseconds): wait(long timeout, int nanos) 方法使当前线程放弃对象的锁并睡眠指定的毫秒数和纳秒数。

语法

notify() 方法

notify() 方法是 Java 编程中的一个同步方法，它会唤醒等待在指定对象上的一个线程。

wait() 和 notify() 之间的区别

Wait()	notify()
当线程调用 wait() 方法时，它会释放持有的监视器锁并进入等待状态。	notify() 方法不会释放锁。它只是告诉其他线程锁可能很快就会被释放。锁的实际释放发生在当前线程完成同步块的执行时。
多个线程可以同时等待。	当一个线程在对象上调用 notify() 方法时，会随机选择一个正在等待该对象的线程并通知它。被通知的线程将退出等待状态，进入阻塞状态。
在 Object 类中，定义了 wait() 方法。	notify() 方法在 Object 类中定义
在线程间通信中，使用 wait() 方法。	要唤醒，使用 notify() 方法唤醒一个线程。
wait() 方法定义在 Java.lang.Object 类中。	notify() 方法没有返回值。
调用 wait() 方法需要同步锁。	notify() 方法唤醒在特定对象上等待的一个线程。

程序

文件名： WaitNotifyDemo.java

class ProducerConsumer {

    private int buffer = 0;
    private boolean isFull = false;

    public synchronized void produce() {
        // While the buffer is full, wait for the consumer to consume items.
        while (isFull) {
            try {
                wait(); // Release the lock and wait until notified.
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        buffer++;
        System.out.println("Producer produced 1 item.");
        isFull = true; // Set the flag to indicate the buffer is full.
        notify(); // Notify the waiting consumer that the buffer is now full and ready for consumption.
    }

    public synchronized void consume() {
        // While the buffer is empty, wait for the producer to produce items.
        while (!isFull) {
            try {
                wait(); // Release the lock and wait until notified.
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        buffer--;
        System.out.println("Consumer consumed 1 item.");
        isFull = false; // Set the flag to indicate the buffer is empty.
        notify(); // Notify the waiting producer that the buffer is now empty and ready for production.
    }
}

public class WaitNotifyDemo {

    public static void main(String[] args) {
        ProducerConsumer producerConsumer = new ProducerConsumer();

        Thread producer = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    producerConsumer.produce();
                }
            }
        });

        Thread consumer = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    producerConsumer.consume();
                }
            }
        });

        producer.start();
        consumer.start();
    }
}

输出

Producer produced 1 item.
Consumer consumed 1 item.
Producer produced 1 item.
Consumer consumed 1 item.
Producer produced 1 item.
Consumer consumed 1 item.
Producer produced 1 item.
Consumer consumed 1 item.
Producer produced 1 item.
Consumer consumed 1 item.
Producer produced 1 item.
Consumer consumed 1 item.
Producer produced 1 item.
Consumer consumed 1 item.
Producer produced 1 item.
Consumer consumed 1 item.
Producer produced 1 item.
Consumer consumed 1 item.
Producer produced 1 item.
Consumer consumed 1 item.

各种异常

1. wait()

InterruptedException: 如果线程在等待时被中断，则抛出此异常。如果另一个线程在等待线程上调用了 interrupt() 方法，则可能发生这种情况。

IllegalMonitorStateException: 如果线程在调用 wait() 方法时未拥有对象的监视器，则抛出此异常。

文件名： WaitDemo.java

class demo {

    volatile boolean part1done = false;

    synchronized void part1() throws InterruptedException {
        System.out.println("Computer");
        part1done = true;
        notify();
    }

    synchronized void part2() throws InterruptedException {
        while (!part1done) {
            wait();
        }
        System.out.println("Keyboard");
    }
}

public class WaitDemo {

    public static void main(String[] args) throws InterruptedException {
        demo obj = new demo();

        Thread t1 = new Thread(new Runnable() {
            public void run() {
                try {
                    obj.part1();
                } catch (InterruptedException e) {
                    System.out.println("Thread t1 interrupted");
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {
            public void run() {
                try {
                    obj.part2();
                } catch (InterruptedException e) {
                    System.out.println("Thread t2 interrupted");
                }
            }
        });

        t2.start();
        t1.start();

        // Interrupt the consumer thread after 5 iterations
        Thread.sleep(3000);
        t2.interrupt();
    }
}

输出

Computer
Keyboard

2. notify()

由于 notify 方法与 wait() 不同，notify 方法不会抛出 InterruptedException，因此无需将其包含在 try-catch 块中。

如果当前线程未拥有调用 notify() 方法的对象的监视器，则会抛出 IllegalMonitorStateException 异常。

文件名： NotifyDemo.java

class Demo {
    volatile boolean part1done = false;
    Integer x = 5;

    void part1() {
        // Synchronized code on "x"
        synchronized (x) {
            System.out.println("Phone");
            part1done = true;
            // calling notify() on the "x" object, which is different from "this" (obj).
            x.notify();
        }
    }

    void part2() {
        // Synchronized code on "x"
        synchronized (x) {
            while (!part1done) {
                try {
                    // calling wait() on the "x" object, which is different from "this" (obj).
                    x.wait();
                } catch (InterruptedException e) {
                    System.out.println("Exception: " + e.getClass());
                    System.exit(-1);
                }
            }
            System.out.println("Electronics");
        }
    }
}

public class NotifyDemo{
    public static void main(String[] args) {
        Demo obj = new Demo();

        Thread t1 = new Thread(() -> obj.part1());
        Thread t2 = new Thread(() -> obj.part2());

        // Start t2 and then t1
        t2.start();
        t1.start();
    }
}

输出

Phone
Electronics

下一个主题Java 中的 Dyck 路径

Java 中 wait 和 notify 的区别

wait() 方法

wait() 方法有三种形式

notify() 方法

wait() 和 notify() 之间的区别

程序

各种异常

1. wait()

2. notify()

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Java Conversion

Java Misc

Java 中 wait 和 notify 的区别

wait() 方法

wait() 方法有三种形式

notify() 方法

wait() 和 notify() 之间的区别

程序

各种异常

1. wait()

2. notify()

相关帖子

Java 中的复合赋值运算符

Java Digital Signature

Java 中的煎饼排序

Groovy vs Java

Unique Number in Java Program

Java 中的 InvocationTargetException

Bastar 和 Java 之间的相似之处

Java 中的 valueOf() 方法

Java 中的 GP 序列问题数量

Java 中运算符的 Unicode

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器