Java多线程系列（二）

线程的等待与通知

---

说起线程的等待与通知，肯定会想到wait()/notify()/notifyAll()。在Java中，Object类是所有类的父类，而这三个方法就是放在Object中，也就是说所有的类都会有上述三个方法。

1. wait()函数

   • 使用wait()函数需要先获取到该对象的锁。如果没有获取到锁则会抛出异常
   • 当一个线程调用一个对象wait()方法时，该线程会被阻塞挂起，会释放对该对象的锁的持有。
   • 当其他线程调用了该对象的notify()或notifyAll()方法，或者其他线程调用该线程的intrupt()方法，使得该线程抛出异常之后，wait()方法才会返回

2. notify()函数

   • 与使用wait()函数相同，使用它也需要首先获取到对象的锁，否则会抛出异常
   • 如果有多个线程调用了该对象的wait()方法，当一个线程调用对象的notify()方法时，它只会随机的唤醒一个线程，需要注意的是，唤醒的线程并不太代表该线程可以执行，他还需要获取到该对象的锁才能执行

3. notifyAll()函数

   • 与使用wait()函数相同，使用它也需要首先获取到对象的锁，否则会抛出异常
   • 如果有多个线程调用了该对象的wait()方法，当一个线程调用对象的notifyAll()方法时，它会唤醒所有的线程

   上述唤醒的线程都是调用wait()函数被挂起的线程，与其他线程无关

   • 一个简单的例子(两个线程，一个wait，一个notify)：

   public class WaitNotifyTest {
   
       public static Object resource = new Object();
   
       public static void main(String[] args) throws InterruptedException{
   
           Thread threada = new Thread(new Runnable() {
               @Override
               public void run(){
                   System.out.println("线程a尝试获取resource的锁");
                   synchronized (resource) {
                       try {
                           System.out.println("线程a获取到了resource的锁");
                           resource.wait();
                           System.out.println("线程a执行完了");
                       }catch (Exception e) {
                           e.printStackTrace();
                       }
   
                   }
               }
           });
   
           Thread threadb = new Thread(new Runnable() {
               @Override
               public void run(){
                   System.out.println("线程b尝试获取resource的锁");
                   synchronized (resource) {
                       try {
                           System.out.println("线程b获取到了resource的锁");
                           resource.notify();
                       }catch (Exception e) {
                           e.printStackTrace();
                       }
                   }
               }
           });
   
           threada.start();
           Thread.sleep(1000);//暂停1s，让线程a执行到wait()
           threadb.start();
       }
   }
   

   输出结果如下：

   线程a尝试获取resource的锁
   线程a获取到了resource的锁
   线程b尝试获取resource的锁
   线程b获取到了resource的锁
   线程a执行完了
   

   上述例子中启动了两个线程，其中线程a先启动，获取到对象resource的锁，然后调用wait()方法挂起，线程b再获取到锁，调用resource对象的notify()方法，此时线程a从挂起状态变为可执行状态，然后获取到锁，继续执行完成

---

• 再来一个例子（三个线程，两个wait，一个notify）

public class WaitNotifyTest {

    private static String resource = "resource";

    public static void main(String[] args) throws Exception{

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程1尝试获取resource的锁");
                try {
                    synchronized (resource) {
                        System.out.println("线程1获取到了resource的锁");
                        resource.wait();
                        System.out.println("线程1被唤醒并继续执行。。。");
                    }
                }catch (Exception e) {
                    e.printStackTrace();
                }

            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程2尝试获取resource的锁");
                try {
                    synchronized (resource) {
                        System.out.println("线程2获取到了resource的锁");
                        resource.wait();
                        System.out.println("线程2被唤醒并继续执行。。。");
                    }
                }catch (Exception e) {
                    e.printStackTrace();
                }

            }
        });

        Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程3尝试获取resource的锁");
                try {
                    synchronized (resource) {
                        System.out.println("线程3获取到了resource的锁");
                        resource.notify();
                        System.out.println("线程3唤醒了某一个线程---");
                    }
                }catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        thread1.start();
        thread2.start();
        Thread.sleep(2000);
        thread3.start();
    }
}

多执行几次会出现如下两种结果：

结果一：
线程1尝试获取resource的锁
线程1获取到了resource的锁
线程2尝试获取resource的锁
线程2获取到了resource的锁
线程3尝试获取resource的锁
线程3获取到了resource的锁
线程3唤醒了某一个线程---
线程1被唤醒并继续执行。。。
结果二：
线程2尝试获取resource的锁
线程2获取到了resource的锁
线程1尝试获取resource的锁
线程1获取到了resource的锁
线程3尝试获取resource的锁
线程3获取到了resource的锁
线程3唤醒了某一个线程---
线程2被唤醒并继续执行。。。

• 再来一个例子（三个线程，两个wait，一个notifyAll）

public class WaitNotifyTest {

    private static String resource = "resource";

    public static void main(String[] args) throws Exception{

        Thread thread1 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程1尝试获取resource的锁");
                try {
                    synchronized (resource) {
                        System.out.println("线程1获取到了resource的锁");
                        resource.wait();
                        System.out.println("线程1被唤醒并继续执行。。。");
                    }
                }catch (Exception e) {
                    e.printStackTrace();
                }

            }
        });

        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程2尝试获取resource的锁");
                try {
                    synchronized (resource) {
                        System.out.println("线程2获取到了resource的锁");
                        resource.wait();
                        System.out.println("线程2被唤醒并继续执行。。。");
                    }
                }catch (Exception e) {
                    e.printStackTrace();
                }

            }
        });

        Thread thread3 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("线程3尝试获取resource的锁");
                try {
                    synchronized (resource) {
                        System.out.println("线程3获取到了resource的锁");
                        resource.notifyAll();
                        System.out.println("线程3唤醒了所有的线程---");
                    }
                }catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });

        thread1.start();
        thread2.start();
        Thread.sleep(2000);
        thread3.start();
    }
}

可以出现以下结果：

线程1尝试获取resource的锁
线程1获取到了resource的锁
线程2尝试获取resource的锁
线程2获取到了resource的锁
线程3尝试获取resource的锁
线程3获取到了resource的锁
线程3唤醒了所有的线程---
线程2被唤醒并继续执行。。。
线程1被唤醒并继续执行。。。

---

上面三个例子可以看出几点：

1. wait方法会释放掉锁，其他线程可以持有该锁
2. notify会随机的唤醒一个调用了wait的线程
3. notifyAll会唤醒所有调用wait的线程，而且唤醒之后并不是可以立即执行，需要争抢锁，谁先抢到谁先执行

如果有说的不对的地方，欢迎留言指正，多谢 ！！！