并发和多线程(四)--wait、notify、notifyAll、sleep、join、yield使用详解

wait、notify、notifyAll

　　这三个方法都是属于Object的，Java中的类默认继承Object，所以在任何方法中都可以直接调用wait()，notifyAll()，notify()，static方法也一样，

new一个对象再调用。这三个方法必须是在获取到monitor锁的前提下使用，也就是使用ReentrantLock这类锁是不行的，只能是synchronized关键字

内部，否则会出现IllegalMonitorStateException异常。

1、wait：

　　作用就是进入阻塞状态，准确的说是Waiting状态，如果调用的wait(timeout)，进入Timed-Waiting状态，并且会释放monitor锁。

调用wait()有四种被唤醒方式：

1).notify

2).notifyAll

3).wait(timeout)

4).interrupt()

　　这几种方式我们都比较熟悉，无论你开发过程中有没有用过多线程，提一下interrupt()，因为无论是调用sleep、wait、join等进入阻塞状态下，都是可以

通过抛出异常响应中断。

基本使用：证明wait()会释放monitor锁

public class ThreadClass {

    private Object object = new Object();

    public static void main(String[] args) throws InterruptedException{
        ThreadClass threadClass = new ThreadClass();
        Thread thread = new Thread(threadClass.new Thread1());
        Thread thread1= new Thread(threadClass.new Thread2());
        thread.start();
        Thread.sleep(100);
        thread1.start();
    }

    class Thread1 implements Runnable{
        @Override
        public void run() {
            synchronized (object) {
                try {
                    System.out.println(Thread.currentThread().getName() + "获取到lock");
                    object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "继续执行");
            }
        }
    }

    class Thread2 implements Runnable{
        @Override
        public void run() {
            synchronized (object) {
                object.notify();
                System.out.println(Thread.currentThread().getName() + "调用了notify");
            }
        }
    }
}

代码实现

结果：
Thread-0获取到lock
Thread-1调用了notify
Thread-0继续执行

　　从结果看，先让Thread-0执行，然后获取Object的monitor锁，然后调用wait进入Waiting状态，Thread-1执行了notify，所以证明wait()释放monitor

锁，否则Thread-1无法进入同步块。Thread-0被唤醒，进入Runnable状态，继而获得CPU使用权，直到执行完成。

wait只释放当前monitor锁

public class ThreadClass {

    private Object object1 = new Object();
    private Object object2 = new Object();

    public static void main(String[] args) throws InterruptedException{
        ThreadClass threadClass = new ThreadClass();
        Thread thread = new Thread(threadClass.new Thread1());
        Thread thread1 = new Thread(threadClass.new Thread2());
        thread.start();
        Thread.sleep(1000);
        thread1.start();
    }

    class Thread1 implements Runnable{
        @Override
        public void run() {
            synchronized (object1) {
                System.out.println(Thread.currentThread().getName() + "获取到object1 monitor lock");
                synchronized (object2) {
                    System.out.println(Thread.currentThread().getName() + "获取到object2 monitor lock");
                    try {
                        System.out.println(Thread.currentThread().getName() + "释放object1 monitor lock");
                        object1.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

    class Thread2 implements Runnable{
        @Override
        public void run() {
            synchronized (object1) {
                System.out.println(Thread.currentThread().getName() + "获取到object1 monitor lock");

                System.out.println(Thread.currentThread().getName() + "尝试获取到object2 monitor lock");
                synchronized (object2) {
                    System.out.println(Thread.currentThread().getName() + "获取到object2 monitor lock");
                }
            }
        }
    }
}

验证wait只释放当前对象的monitor

结果：
Thread-0获取到object1 monitor lock
Thread-0获取到object2 monitor lock
Thread-0释放object1 monitor lock
Thread-1获取到object1 monitor lock
Thread-1尝试获取到object2 monitor lock

代码执行流程：

①.Thread-0获取object1、object2的monitor锁，但是只释放object1的锁

②.Thread-1在Thread-0是否object1的锁之后，获取到object1的锁，但是无法获取object2的锁

所以证明，wait只释放当前对象的monitor。

wait()工作原理

原理解释：

 入口集 Entry Set，等待集Wait Set

1、新启动的线程，会进入Entry Set去竞争monitor锁

2、其中一个线程得到monitor锁，进入红色区域，成为owner

3、此时有两个可能realise，如果调用wait()，进入Wait Set

4、直到被notify/notifyAll唤醒，进入最下面一层

5、此时和第二步一样都要去竞争获取锁，就是Blocked状态

6、程序执行结束，退出

2、notify、notifyAll

　　从上面的代码中看到notify可以唤醒Waiting状态下的Thread，进入Runnable状态，但不一定立刻获取monitor锁，首先要等待别的Thread释放monitor

锁，然后通过CPU调度是否获取锁。

notify：通过jvm选择唤醒其中一个调用wait()进入Waiting状态下的线程。

notifyAll：唤醒所有调用wait()进入Waiting状态下的线程。

public class ThreadClass {

    private Object object = new Object();

    public static void main(String[] args) throws InterruptedException{
        ThreadClass threadClass = new ThreadClass();
        Thread thread = new Thread(threadClass.new Thread1());
        Thread thread1 = new Thread(threadClass.new Thread1());
        Thread thread2= new Thread(threadClass.new Thread2());
        thread.start();
        thread1.start();
        //休眠100ms保证notifyAll()后执行
        Thread.sleep(100);
        thread2.start();
    }

    class Thread1 implements Runnable{
        @Override
        public void run() {
            synchronized (object) {
                try {
                    System.out.println(Thread.currentThread().getName() + "获取到lock");
                    object.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "继续执行");
            }
        }
    }

    class Thread2 implements Runnable{
        @Override
        public void run() {
            synchronized (object) {
                object.notifyAll();
                System.out.println(Thread.currentThread().getName() + "调用了notify");
            }
        }
    }
}

notifyAll代码测试

结果：
Thread-0获取到lock
Thread-1获取到lock
Thread-2调用了notify
Thread-1继续执行
Thread-0继续执行

代码执行流程：

①.Thread-0和Thread-1启动

②.Thread-0获取到lock，然后执行wait()释放锁

③.Thread-1先进入Blocked状态，等待Thread-0释放锁之后，执行代码，然后执行wait()

④.Thread-2启动，执行notifyAll()，将所有因为wait()进入等待的线程唤醒

⑤.Thread-0和Thread-1竞争monitor锁，然后Thread-1得到锁，执行完成，释放锁

⑥.Thread-0获得锁，执行完成，释放锁

所以证明notifyAll()能够唤醒所有调用wait()进入Waiting状态的线程，如果改成notify()，只会有一个线程继续执行。

总结：

1、wait()、notify()、notifyAll()都需要先获取monitor锁才能执行，否则抛出异常

2、notify只能获取一个调用wait()进入Waiting状态的线程，由jvm决定唤醒哪个，无法提前预知

3、notifyAll唤醒全部调用wait()进入Waiting状态的线程

4、wait()、notify()、notifyAll()都属于Object

思考题：为什么wait()需要在Synchronized内部使用，而sleep()不需要？

　　为了防止死锁、永久等待的发生，如果没有这个前提，Thread-0在执行代码的时候，如果线程上下文切换到Thread-1，Thread-1直接执行notify了，

但是Thread-0还没执行wait()，然后切换回来Thread-0，执行wait()之后，就只能永久等待了。但是如果在Synchronized内部，如果没有释放锁，其他线程

不能进入的，能够避免这种可能的发生。

　　而sleep只会休眠一段时间，不会出现永久等待的可能。