Java notify 方法的使用示例有哪些？

Java中的notify()方法是多线程编程中的一个重要方法，用于控制线程的等待和唤醒操作。通过notify()方法，我们可以在一个线程中通知正在等待的其他线程继续执行。

下面我们将介绍几个使用notify()方法的示例：

示例1：线程间的等待和唤醒
class MyThread extends Thread {
    private Object lock;
    public MyThread(Object lock) {
        this.lock = lock;
    }
    public void run() {
        synchronized(lock) {
            System.out.println("线程A开始执行...");
            try {
                lock.wait(); // 线程A等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程A继续执行...");
        }
    }
}
public class NotifyExample {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        MyThread threadA = new MyThread(lock);
        threadA.start();
        
        Thread.sleep(1000); // 等待1秒，确保线程A已经进入等待状态
        
        synchronized(lock) {
            System.out.println("唤醒线程A...");
            lock.notify(); // 唤醒线程A
        }
    }
}
在这个示例中，我们创建了一个MyThread类继承自Thread，并在其中使用了wait()方法进行线程等待。main()函数中，我们创建了一个锁对象lock，并通过该对象实例化线程A。首先线程A开始执行，并通过lock.wait()方法进入等待状态。然后在主线程中等待1秒后，通过lock.notify()方法唤醒线程A，使其继续执行。

运行上述代码，输出如下：
线程A开始执行...
唤醒线程A...
线程A继续执行...
示例2：多线程协调
class MyThread extends Thread {
    private Object lock;
    public MyThread(Object lock) {
        this.lock = lock;
    }
    public void run() {
        synchronized(lock) {
            System.out.println("线程A开始执行...");
            try {
                lock.wait(); // 线程A等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程A继续执行...");
        }
    }
}
public class NotifyExample {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        MyThread threadA = new MyThread(lock);
        MyThread threadB = new MyThread(lock);
        threadA.start();
        threadB.start();
        
        Thread.sleep(1000); // 等待1秒，确保两个线程都已经进入等待状态
        
        synchronized(lock) {
            System.out.println("唤醒所有线程...");
            lock.notifyAll(); // 唤醒所有线程
        }
    }
}
在这个示例中，我们创建了多个线程，都使用了相同的锁对象lock，使得线程间可以相互通信。通过lock.notifyAll()方法，可以唤醒所有等待的线程，使它们继续执行。

运行上述代码，输出如下：
线程A开始执行...
线程B开始执行...
唤醒所有线程...
线程A继续执行...
线程B继续执行...
示例3：避免线程死锁
public class DeadlockExample {
    private static Object lock1 = new Object();
    private static Object lock2 = new Object();
    public static void main(String[] args) {
        Thread threadA = new Thread(() -> {
            synchronized(lock1) {
                System.out.println("线程A获取到锁1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程A等待获取锁2");
                synchronized(lock2) {
                    System.out.println("线程A获取到锁2");
                }
            }
        });
        Thread threadB = new Thread(() -> {
            synchronized(lock2) {
                System.out.println("线程B获取到锁2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程B等待获取锁1");
                synchronized(lock1) {
                    System.out.println("线程B获取到锁1");
                }
            }
        });
        threadA.start();
        threadB.start();
    }
}
在这个示例中，我们创建了两个线程A和B，它们分别获取lock1和lock2这两个锁对象。如果线程A先获取到lock1，然后等待获取lock2，同时线程B先获取到lock2，然后等待获取lock1，就会造成死锁。为了避免这种情况，我们可以在合适的时机使用notify()方法唤醒等待的线程，从而破坏死锁状态。

以上是几个关于Java notify()方法的使用示例，通过这些示例我们可以更好地理解和掌握notify()方法的作用和用法。

示例1：线程间的等待和唤醒

示例2：多线程协调

示例3：避免线程死锁

江明涛