一张图搞清楚wait、sleep、join、yield四者区别，面试官直接被征服！

写在开头

在线程的生命周期中，不同状态之间切换时，可以通过调用sleep()、wait()、join()、yield(）等方法进行线程状态控制，针对这一部分知识点，面试官们也会做做文章，比如问你这些方法的作用以及之间的区别。

那么今天我们就一起来总结一下这几个方法的作用及区别，先画一个思维导图梳理一下，便于理解与记忆，争取在被问到这个点时彻底征服面试官！（图片可保存常看哈）
在这里插入图片描述

sleep()

sleep()是Thread类中的一个静态本地方法，通过设置方法中的时间参数，使调用它的线程休眠指定时间，线程从RUNNING状态转为BLOCKED状态，这个过程中会释放CPU资源，给其他线程运行机会时不考虑线程的优先级，但如果有同步锁则sleep不会释放锁即其他线程无法获得同步锁，需要注意的是sleep()使用时要处理异常。休眠时间未到时，可通过调用interrupt()方法来唤醒休眠线程。

【代码示例1】

try {//sleep会发生异常要显示处理
    Thread.sleep(20);//暂停20毫秒
} catch (InterruptedException e) {
    e.printStackTrace();
}

为什么sleep()放在Thread类中

答：因为sleep是线程级别的休眠，不涉及到对象类，只是让当前线程暂停，进入休眠状态，并不释放同步锁资源，也不需要去获得对象锁。

wait()

wait() 是Object类的成员本地方法，会让持有对象锁的线程释放锁，进入线程等待池中等待被再次唤醒(notify随机唤醒，notifyAll全部唤醒，线程结束自动唤醒)即放入锁池中竞争同步锁，同时释放CPU资源，它的调用必须在同步方法或同步代码块中执行，也需要捕获 InterruptedException 异常。

【代码示例2】

//同步代码块
 synchronized (obj) {
     System.out.println("obj to wait on RunnableImpl1");
     try {
         obj.wait();
     } catch (InterruptedException e) {
         e.printStackTrace();
     }
     System.out.println("obj continue to run on RunnableImpl1");
 }

为什么wait()是Object的方法

答：每个对象都拥有对象锁，wait的作用是释放当前线程所占有的对象锁，自然是要操作对应的Object而不是Thread，因此wait要放入到Object中。

join()

join()同样是Thread中的一个方法，调用join的线程拥有优先使用CPU时间片的权利，其他线程需要等待join()调用线程执行结束后才能继续执行，探索其底层会发现，它的底层是通过wait()进行实现，因此它也需要处理异常。

【代码示例3】

//创建TestRunnable类
TestRunnable mr = new TestRunnable();
//创建Thread类的有参构造,并设置线程名
Thread t1 = new Thread(mr, "t1");
Thread t2 = new Thread(mr, "t2");
Thread t3 = new Thread(mr, "t3");
//启动线程
t1.start();
try {
    t1.join(); //等待t1执行完才会轮到t2，t3抢
} catch (InterruptedException e) {
    e.printStackTrace();
}
t2.start();
t3.start();

我们跟进join()方法内部会发现，其底层主要通过wait()实现，其中参数代表等待当前线程最多执行 millis 毫秒，如果 millis 为 0，则会一直执行，直至完成，其他线程才会继续向下；

【源码示例1】

    public final synchronized void join(long millis)
    throws InterruptedException {
        long base = System.currentTimeMillis();
        long now = 0;

        if (millis < 0) {
            throw new IllegalArgumentException("timeout value is negative");
        }

        if (millis == 0) {
            while (isAlive()) {
                wait(0);
            }
        } else {
            while (isAlive()) {
                long delay = millis - now;
                if (delay <= 0) {
                    break;
                }
                wait(delay);
                now = System.currentTimeMillis() - base;
            }
        }
    }

yield()

yield()是Thread的一个静态方法，它的调用不需要传入时间参数，并且yield() 方法只会给相同优先级或更高优先级的线程运行的机会，并且调用yield的线程状态会转为就绪状态，调用yield方法只是一个建议，告诉线程调度器我的工作已经做的差不多了，可以让别的线程使用CPU了，没有任何机制保证采纳。所以可能它刚让出CPU时间片，又被线程调度器分配了一个时间片继续执行了。使用时不需要处理异常。

【代码示例4】

public class Test {

    public static void main(String[] args) {
        Thread thread1 = new Thread(Test::printNumbers, "小明");
        Thread thread2 = new Thread(Test::printNumbers, "小华");
        thread1.start();
        thread2.start();
    }
    private static void printNumbers() {
        for (int i = 1; i <= 5; i++) {
            System.out.println(Thread.currentThread().getName() + ": " + i);

            // 当 i 是偶数时，当前线程暂停执行
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + " 让出控制权...");
                Thread.yield();
            }
        }
    }
}

输出：

小明: 1
小华: 1
小华: 2
小明: 2
小明 让出控制权...
小华 让出控制权...
小明: 3
小明: 4
小明 让出控制权...
小明: 5
小华: 3
小华: 4
小华 让出控制权...
小华: 5

总结

上文中，我们结合代码示例，对这个四个方法进行了详细介绍，下面我们以sleep()为参照，进行对比总结：

（1）sleep()与wait()的区别？

sleep() 是 Thread 类的静态本地方法；wait() 是Object类的成员本地方法；
JDK1.8 sleep() wait() 均需要捕获 InterruptedException 异常；
sleep() 方法可以在任何地方使用；wait() 方法则只能在同步方法或同步代码块中使用；
sleep() 会休眠当前线程指定时间，释放 CPU 资源，不释放对象锁，休眠时间到自动苏醒继续执行；wait() 方法放弃持有的对象锁，进入等待队列，当该对象被调用 notify() / notifyAll() 方法后才有机会竞争获取对象锁，进入运行状态。

（2）sleep()与yield()的区别？