Java多线程中的wait方法

在Java多线程编程中,wait方法是用于线程间通信的重要方法之一。它提供了一种机制,允许线程之间进行协调和同步。本文将详细介绍Java中的wait方法,并提供一些代码示例来帮助读者更好地理解。

什么是wait方法?

wait方法是Object类中定义的一个方法,所有的Java对象都可以使用该方法。它用于在一个线程中暂停执行,直到其他线程调用该对象的notify或notifyAll方法唤醒它。

wait方法的定义如下:

public final void wait() throws InterruptedException

wait方法有以下几个特点:

  1. wait方法必须在同步代码块或同步方法中调用。否则会抛出IllegalMonitorStateException异常。

  2. 调用wait方法后,线程会释放它所持有的锁,进入等待状态。

  3. 当其他线程调用该对象的notify或notifyAll方法时,等待的线程将被唤醒,继续执行。

  4. wait方法还可以指定等待的时间,如下:

    public final void wait(long timeout) throws InterruptedException
    

    这样,线程在等待一定时间后,如果没有被唤醒,将自动恢复执行。

wait方法的使用示例

下面是一个简单的示例,演示了wait方法的基本使用方法:

public class WaitExample {
   public static void main(String[] args) {
       final Object lock = new Object();
       
       Thread thread1 = new Thread(new Runnable() {
           @Override
           public void run() {
               synchronized (lock) {
                   try {
                       System.out.println("Thread 1: Waiting");
                       lock.wait();
                       System.out.println("Thread 1: Woken up");
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           }
       });
       
       Thread thread2 = new Thread(new Runnable() {
           @Override
           public void run() {
               synchronized (lock) {
                   try {
                       Thread.sleep(2000);
                       System.out.println("Thread 2: Notifying");
                       lock.notify();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           }
       });
       
       thread1.start();
       thread2.start();
   }
}

在上述代码中,我们创建了两个线程thread1和thread2,并给它们传递了相同的锁对象lock。在thread1中,我们使用了lock对象的wait方法进行等待。在thread2中,我们使用了lock对象的notify方法来唤醒等待的线程。

输出结果如下:

Thread 1: Waiting
Thread 2: Notifying
Thread 1: Woken up

从输出结果可以看出,thread1在等待期间被thread2唤醒,继续执行。

等待时间的设置

我们可以使用wait方法的另一种重载形式,来设置等待的时间。下面是一个示例:

public class WaitExample2 {
    public static void main(String[] args) {
        final Object lock = new Object();
        
        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    try {
                        System.out.println("Thread 1: Waiting");
                        lock.wait(5000);
                        System.out.println("Thread 1: Woken up");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                synchronized (lock) {
                    try {
                        Thread.sleep(2000);
                        System.out.println("Thread 2: Notifying");
                        lock.notify();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        });
        
        thread1.start();
        thread2.start();
    }
}

在上述代码中,我们将等待时间设置为5000毫秒(即5秒)。因此,如果在5秒内没有其他线程唤醒等待的线程,它将自动恢复执行。

注意事项

在使用wait方法时,需要注意以下几点:

  1. wait方法必须在同步代码块或同步方法中调用,否则会抛出IllegalMonitorStateException异常。

  2. 调用wait方法后,线程会释放它所持有的锁,进入等待状态。因此,在调