Java 多线程中的 wait 方法：深入解析与实践

简介

在 Java 多线程编程中，wait 方法是一个强大且重要的工具，它允许线程之间进行有效的通信和同步。理解 wait 方法的工作原理以及如何正确使用它，对于编写高效、可靠的多线程应用程序至关重要。本文将深入探讨 wait 方法的基础概念、使用方法、常见实践以及最佳实践，帮助读者更好地掌握这一关键技术。

目录

1. 基础概念
   • wait 方法的定义与作用
   • 与对象锁的关系
2. 使用方法
   • wait() 方法
   • wait(long timeout) 方法
   • wait(long timeout, int nanos) 方法
3. 常见实践
   • 生产者 - 消费者模型
   • 线程间同步
4. 最佳实践
   • 避免死锁
   • 合理设置等待时间
   • 正确处理中断
5. 小结
6. 参考资料

基础概念

wait 方法的定义与作用

wait 方法是定义在 java.lang.Object 类中的实例方法，这意味着 Java 中的所有对象都可以调用 wait 方法。其主要作用是使当前线程等待，直到其他线程调用该对象的 notify() 或 notifyAll() 方法。当一个线程调用对象的 wait 方法时，它会释放该对象的锁，进入等待状态，直到被唤醒。

与对象锁的关系

wait 方法必须在同步代码块（synchronized 块）或同步方法中调用。这是因为调用 wait 方法时，线程需要释放对象的锁，以便其他线程能够获取该锁并调用 notify() 或 notifyAll() 方法来唤醒等待的线程。如果在非同步环境中调用 wait 方法，会抛出 IllegalMonitorStateException 异常。

使用方法

wait() 方法

这是最基本的 wait 方法调用形式，它会使当前线程无限期等待，直到其他线程调用该对象的 notify() 或 notifyAll() 方法。

public class WaitExample {
    public static void main(String[] args) {
        Object lock = new Object();

        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("线程1开始等待");
                    lock.wait();
                    System.out.println("线程1被唤醒");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程2获取锁");
                lock.notify();
                System.out.println("线程2调用 notify 方法");
            }
        });

        thread1.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.start();
    }
}

wait(long timeout) 方法

该方法允许指定一个最长等待时间（以毫秒为单位）。如果在指定的时间内没有其他线程调用该对象的 notify() 或 notifyAll() 方法，那么等待的线程会自动唤醒。

public class WaitTimeoutExample {
    public static void main(String[] args) {
        Object lock = new Object();

        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("线程1开始等待，等待时间为 2000 毫秒");
                    lock.wait(2000);
                    System.out.println("线程1被唤醒或等待超时");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        thread1.start();
    }
}

wait(long timeout, int nanos) 方法

此方法提供了更精确的等待时间控制，允许指定等待的毫秒数和额外的纳秒数。

public class WaitNanosExample {
    public static void main(String[] args) {
        Object lock = new Object();

        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("线程1开始等待，等待时间为 1 秒 500000 纳秒");
                    lock.wait(1000, 500000);
                    System.out.println("线程1被唤醒或等待超时");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        thread1.start();
    }
}

常见实践

生产者 - 消费者模型

生产者 - 消费者模型是多线程编程中的经典示例，wait 和 notify 方法在其中起着关键作用。生产者线程生成数据并将其放入共享缓冲区，消费者线程从缓冲区中取出数据进行处理。当缓冲区满时，生产者线程需要等待；当缓冲区空时，消费者线程需要等待。

import java.util.LinkedList;
import java.util.Queue;

class Producer implements Runnable {
    private final Queue<Integer> queue;
    private final int capacity;

    public Producer(Queue<Integer> queue, int capacity) {
        this.queue = queue;
        this.capacity = capacity;
    }

    @Override
    public void run() {
        int value = 0;
        while (true) {
            synchronized (queue) {
                while (queue.size() == capacity) {
                    try {
                        System.out.println("缓冲区已满，生产者等待");
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                queue.add(value++);
                System.out.println("生产者生产: " + value);
                queue.notify();
            }
        }
    }
}

class Consumer implements Runnable {
    private final Queue<Integer> queue;

    public Consumer(Queue<Integer> queue) {
        this.queue = queue;
    }

    @Override
    public void run() {
        while (true) {
            synchronized (queue) {
                while (queue.isEmpty()) {
                    try {
                        System.out.println("缓冲区为空，消费者等待");
                        queue.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                int value = queue.poll();
                System.out.println("消费者消费: " + value);
                queue.notify();
            }
        }
    }
}

public class ProducerConsumerExample {
    public static void main(String[] args) {
        Queue<Integer> queue = new LinkedList<>();
        int capacity = 5;

        Thread producerThread = new Thread(new Producer(queue, capacity));
        Thread consumerThread = new Thread(new Consumer(queue));

        producerThread.start();
        consumerThread.start();
    }
}

线程间同步

在某些情况下，我们需要确保多个线程按照特定的顺序执行。wait 和 notify 方法可以用于实现这种线程间的同步。

public class ThreadSyncExample {
    private static Object lock = new Object();
    private static boolean flag = false;

    public static void main(String[] args) {
        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                while (!flag) {
                    try {
                        System.out.println("线程1等待");
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("线程1继续执行");
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程2设置标志并唤醒线程1");
                flag = true;
                lock.notify();
            }
        });

        thread1.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread2.start();
    }
}

最佳实践

避免死锁

死锁是多线程编程中常见的问题，当两个或多个线程相互等待对方释放锁时就会发生死锁。为了避免死锁，应该遵循以下原则： - 尽量减少锁的持有时间，避免在锁内执行长时间的操作。 - 确保线程获取锁的顺序一致，避免交叉获取锁。 - 使用 tryLock 方法来尝试获取锁，并设置合理的超时时间。

合理设置等待时间

在使用 wait(long timeout) 方法时，应该根据实际情况合理设置等待时间。如果等待时间过短，可能会导致线程频繁唤醒和重新等待，增加系统开销；如果等待时间过长，可能会导致线程长时间阻塞，影响系统响应性能。

正确处理中断

wait 方法会抛出 InterruptedException 异常，因此在调用 wait 方法时应该正确处理该异常。通常情况下，应该在捕获异常后清理资源并终止线程。

public class InterruptExample {
    public static void main(String[] args) {
        Object lock = new Object();

        Thread thread1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("线程1开始等待");
                    lock.wait();
                    System.out.println("线程1被唤醒");
                } catch (InterruptedException e) {
                    System.out.println("线程1被中断");
                    // 清理资源并终止线程
                }
            }
        });

        thread1.start();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thread1.interrupt();
    }
}

小结

wait 方法是 Java 多线程编程中实现线程间通信和同步的重要手段。通过合理使用 wait 方法，可以有效地协调多个线程的执行顺序，提高程序的并发性能。在使用 wait 方法时，需要注意与对象锁的关系，正确处理等待时间和中断情况，避免死锁等问题。希望本文的介绍和示例能够帮助读者更好地理解和应用 wait 方法，编写出高效、可靠的多线程程序。

参考资料

• Java 官方文档 - Object 类
• 《Effective Java》 - Joshua Bloch
• 《Java 并发编程实战》 - Brian Goetz

以上就是关于 wait java thread 的详细技术博客，希望对您有所帮助。如果您有任何疑问或建议，欢迎留言讨论。