【线程基础】wait/notify/sleep/join等重要用法以及注意事项

使用方法

wait

方法	作用
wait()	将当前运行的线程挂起（即让其进入阻塞状态），直到notify或notifyAll方法来唤醒线程。
wait(long timeout)	该方法与wait()方法类似，唯一的区别就是在指定时间内，如果没有notify或notifAll方法的唤醒，也会自动唤醒。
wait(long timeout,long nanos)	相对于wait(long timeout)来说，拥有更精确的控制调度时间。

notify

方法	作用
notify()	唤醒一个被wait挂起的线程
notifyAll()	唤醒所有被wait挂起的线程

sleep

方法	作用
sleep(long timeout)	让当前线程暂停指定的时间（毫秒）

yield

方法	作用
yield()	暂停当前线程，以便其他线程有机会执行。将线程的Running状态转变为Runnable状态

join

方法	作用
join()	让父线程等待子线程执行完成后再执行
join(long millis)	content2
join(long millis, int nanos)	等待millis 毫秒终止线程，假如这段时间内该线程还没执行完，将取消等待。
join(long millis, int nanos)	相对于join(long millis)来说，拥有更精确的控制调度时间。

注意事项

wait 必须在 synchronized 保护的同步代码中使用

首先我们先看看wait方法源码里面是怎么写的
wait method should always be used in a loop:

 synchronized (obj) {

     while (condition does not hold)

         obj.wait();

     ... // Perform action appropriate to condition

}

This method should only be called by a thread that is the owner of this object's monitor.

这里的意思是说，在使用 wait 方法时，必须把 wait 方法写在 synchronized 保护的 while 代码块中，并始终判断执行条件是否满足，如果满足就往下继续执行，如果不满足就执行 wait 方法，而在执行 wait 方法之前，必须先持有对象的 monitor 锁，也就是通常所说的 synchronized 锁。

我可以先看一下下面这段代码

public class WaitsMain {

    private static String a = "";

    public static void main(String[] args) {
        Thread thread01 = new Thread(()->{
                System.out.println(Thread.currentThread().getName()+" 抢到了锁");
                try {
                    System.out.println(Thread.currentThread().getName()+" 释放锁");
                    a.wait();
                    System.out.println(Thread.currentThread().getName()+" 执行结束了");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

        });

        Thread thread02 = new Thread(()->{
                System.out.println(Thread.currentThread().getName()+" 抢到了锁");
                a.notify();
                System.out.println(Thread.currentThread().getName()+" 唤醒了锁");
        });

        thread01.start();
        thread02.start();

    }
}

在不加锁的情况下，这段代码如果执行，会出现如下情况

Thread-0 抢到了锁
Thread-0 释放锁
Thread-1 抢到了锁
Exception in thread "Thread-0" Exception in thread "Thread-1" java.lang.IllegalMonitorStateException
	at java.lang.Object.notify(Native Method)
	at src.com.thread.waits.WaitsMain.lambda$main$1(WaitsMain.java:22)
	at java.lang.Thread.run(Thread.java:748)
java.lang.IllegalMonitorStateException
	at java.lang.Object.wait(Native Method)
	at java.lang.Object.wait(Object.java:502)
	at src.com.thread.waits.WaitsMain.lambda$main$0(WaitsMain.java:12)
	at java.lang.Thread.run(Thread.java:748)

可以看到报错信息出现了IllegalMonitorStateException这个报错，这个报错会在三种情况下抛出：

• 当前线程不含有当前对象的锁资源的时候，调用obj.wait()方法;
• 当前线程不含有当前对象的锁资源的时候，调用obj.notify()方法。
• 当前线程不含有当前对象的锁资源的时候，调用obj.notifyAll()方法。

很明显上段代码中就是因为Thread-1线程没有获取到当前对象锁资源然后去调用notify方法导致出现异常，所以如果在不加锁的情况下，贸然的去使用wait和notify可能会导致整个流程的操作没有在一个原子性的环境下去完成。接下来我们去改进一下上面这段代码

public class WaitsMain {

    private static String a = "";

    public static void main(String[] args) {
        Thread thread01 = new Thread(()->{

            synchronized (a){
                System.out.println(Thread.currentThread().getName()+" 抢到了锁");
                try {
                    System.out.println(Thread.currentThread().getName()+" 释放锁");
                    a.wait();
                    System.out.println(Thread.currentThread().getName()+" 执行结束了");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        Thread thread02 = new Thread(()->{
            synchronized (a){
                System.out.println(Thread.currentThread().getName()+" 抢到了锁");
                a.notify();
                System.out.println(Thread.currentThread().getName()+" 唤醒了锁");
            }
        });

        thread01.start();
        thread02.start();

    }
}

控制台输出：

Thread-0 抢到了锁
Thread-0 释放锁
Thread-1 抢到了锁
Thread-1 唤醒了锁
Thread-0 执行结束了

在我们改进后的代码之后，会发现加了锁的代码，wait方法在释放monitor锁的时候，就必须要先进入到synchronized内持有这把锁，这样才能够提高线程的安全性。

wait/notify 和 sleep 方法的异同

相同点

• 他们都可以让线程阻塞
• 它们都可以响应 interrupt 中断：在等待的过程中如果收到中断信号，都可以进行响应，并抛出 InterruptedException 异常。

不同点

• wait 方法必须在 synchronized 保护的代码中使用，而 sleep 方法并没有这个要求。
• 在同步代码中执行 sleep 方法时，并不会释放 monitor 锁，但执行 wait 方法时会主动释放 monitor 锁。
• sleep 方法中会要求必须定义一个时间，时间到期后会主动恢复，而对于没有参数的 wait 方法而言，意味着永久等待，直到被中断或被唤醒才能恢复，它并不会主动恢复。
• wait/notify 是 Object 类的方法，而 sleep 是 Thread 类的方法。

为什么 wait/notify/notifyAll 被定义在 Object 类中，而 sleep 定义在 Thread 类中

• 因为 Java 中每个对象都有一把称之为 monitor 监视器的锁，由于每个对象都可以上锁，这就要求在对象头中有一个用来保存锁信息的位置。这个锁是对象级别的，而非线程级别的，wait/notify/notifyAll 也都是锁级别的操作，它们的锁属于对象，所以把它们定义在 Object 类中是最合适，因为 Object 类是所有对象的父类。
• 因为如果把 wait/notify/notifyAll 方法定义在 Thread 类中，会带来很大的局限性，比如一个线程可能持有多把锁，以便实现相互配合的复杂逻辑，假设此时 wait 方法定义在 Thread 类中，如何实现让一个线程持有多把锁呢？又如何明确线程等待的是哪把锁呢？既然我们是让当前线程去等待某个对象的锁，自然应该通过操作对象来实现，而不是操作线程。

yield()注意事项

• yield是一个静态的本地方法（native）
• 调用yield后，yield告诉当前线程把运行机会交给线程池中有相同优先级的线程。
• yield不能保证，当前线程迅速从运行状态切换到就绪状态。
• yield只能是将当前线程从运行状态转换到就绪状态，而不能是等待或者阻塞状态。

join()的实现原理

join()方法实现是通过wait()。 当main线程调用t.join时候，main线程会获得线程对象t的锁（wait 意味着拿到该对象的锁),调用该对象的wait()，直到该对象唤醒main线程 ，比如退出后。这就意味着main 线程调用t.join时，必须能够拿到线程t对象的锁。
详细可以看一下join的源码

join()和yield的区别

yield()做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

join()方法则是可以使得一个线程在另一个线程结束后再执行。如果join()方法在一个线程实例上调用，当前运行着的线程将阻塞直到这个线程实例完成了执行。