【Java】多线程-wait/notify

1、wait和notify

Java的多线程中，线程的执行顺序和时间都是不定的。为了控制线程的调度顺序，前面我们引入了join()方法。

但是join()只能在线程执行完后，才能执行其他线程，有没有什么方法可以在线程执行顺序中来调度其他线程呢？

这里我们引入了wait()和notify()方法

wait()、notify()和notifyAll()都是属于Object类中的方法，任何对象都可以调用这几个方法

wait()/wait(time)：让当前进程进入阻塞状态

notify()/notifyAll()：唤醒当前对象上等待的对象

wait()的基本用法是

Object object = new Object();
synchronized (object){
   try {
       object.wait();
   } catch (InterruptedException e) {
       throw new RuntimeException(e);
   }
       

notify()基本用法

synchronized (object){
      object.notify();
} 

2、注意事项

（1）wait()和notify()在使用时都要加锁

在使用上述三个方法时，需要对竞争资源进行加锁，不然就会报错

并且wait()方法在使用时，线程必须获得锁对象的控制权

（2）阻塞状态

线程调用wait()方法后，线程进入阻塞状态（WAITING）

阻塞状态什么也不做，不会占用CPU

 

（3） notify的调用位置

对象调用wait方法后，对象锁被释放，这时必须由其他线程来唤醒对象

如果将notify写在同一线程中，则不能唤醒当前对象

public class demo {
    public static void main(String[] args) {
        Object object = new Object();
        System.out.println("开始进程");
        synchronized (object){
            try {
                object.wait();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            object.notify();
        }
        System.out.println("结束进程");
    }
}

线程会继续阻塞 

3、wait()带参数方法和notifyAll()

 （1）wait()带参数方法

 wait(long timeout)中的参数表示线程阻塞的超时时间，如果超过这个时长，那么线程会被自动唤醒

避免无休止地等待下去

public class demo {
    public static void main(String[] args) {
        Object object = new Object();
        Thread thread1 = new Thread(()->{
            synchronized (object){
                System.out.println("线程1开始执行");
                try {
                    object.wait(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程1执行结束");
            }
        });

        Thread thread2 = new Thread(()->{
            System.out.println("线程2开始执行");
            System.out.println("线程2执行结束");
        });

        thread1.start();
        thread2.start();

    }
}

上述代码中，并没有对线程1进行唤醒操作，而是在1000ms的等待时间结束后，线程1自动唤醒，打印结果并结束线程 

（2）notifyAll() 

notify()一次唤醒一个线程，notifyAll() 一次唤醒全部线程

由于唤醒线程的过程中也要进行锁的竞争，因此notifyAll()的唤醒并不是并行执行，而是串行执行的

 · 多次notify()唤醒多个线程

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

        Thread thread1 = new Thread(()->{
            synchronized (object){
                System.out.println("线程1开始执行");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程1拿回锁");
                System.out.println("线程1执行完毕");
            }
        });

        Thread thread2 = new Thread(()->{
            synchronized (object){
                System.out.println("线程2开始执行");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程2拿回锁");
                System.out.println("线程2执行完毕");
            }
        });

        Thread thread3 = new Thread(()->{
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (object){
                System.out.println("线程3开始执行");
                object.notify();
                object.notify();
                System.out.println("线程释放锁");
                System.out.println("线程3执行完毕");
            }
        });

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

线程3唤醒两次，使得线程1和线程2先后拿回锁

 · notifyAll() 

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

        Thread thread1 = new Thread(()->{
            synchronized (object){
                System.out.println("线程1开始执行");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程1拿回锁");
                System.out.println("线程1执行完毕");
            }
        });

        Thread thread2 = new Thread(()->{
            synchronized (object){
                System.out.println("线程2开始执行");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程2拿回锁");
                System.out.println("线程2执行完毕");
            }
        });

        Thread thread3 = new Thread(()->{
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            synchronized (object){
                System.out.println("线程3开始执行");
                object.notifyAll();
                System.out.println("线程释放锁");
                System.out.println("线程3执行完毕");
            }
        });

        thread1.start();
        thread2.start();
        thread3.start();
    }
}

执行结果

 

3、关于锁释放的时间

在线程2唤醒 线程1后，线程2会立即释放锁吗？

我们通过一段代码来验证一下

public class demo {
    public static void main(String[] args) {
        Object object = new Object();
        Thread thread1 = new Thread(()->{
            synchronized (object){
                System.out.println("线程1开始执行");
                try {
                    object.wait();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程1拿回锁");
                System.out.println("线程1执行结束");
            }
        });

        Thread thread2 = new Thread(()->{
            synchronized (object){
                System.out.println("线程2拿到锁");
                System.out.println("线程2开始执行");
                System.out.println("线程2释放锁");
                object.notify();
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("线程2执行结束");
            }
        });

        thread1.start();
        thread2.start();
    }
}

上述代码执行结果为：

可以看到，在线程2调用notify()唤醒线程1后，就算进行了休眠，也并没有释放锁；而是在线程2的代码全部执行完后，线程2才释放锁

所以，我们可以得出的结论是：在一个线程唤醒其他线程后，它不会立即释放锁，而是要在本线程代码执行完后才释放锁