sleep、yield、join方法简介与用法 sleep与wait区别 多线程中篇（十五）

Object中的wait、notify、notifyAll，能够用于线程间的通讯，核心原理为借助于监视器的入口集与等待集逻辑

经过这三个方法完成线程在指定锁（监视器）上的等待与唤醒，这三个方法是以锁（监视器）为中心的通讯方法 

除了他们以外，还有用于线程调度、控制的方法，他们是sleep、yield、join方法，他们能够用于线程的协做，他们是围绕着线程的调度而来的 

sleep方法

有两个版本的sleep方法，看得出来，核心仍旧是native方法

非native方法只是进行了参数校验，接着仍旧是调用的native方法，这个情形与wait是相似的

接下来仔细看下，native版本的sleep

在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操做受到系统计时器和调度程序精度和准确性的影响。该线程不丢失任何监视器的所属权。

注意：

sleep不会释放锁，不会释放锁，不会释放锁

能够理解为他进入监视器这个房间以后，在这房间里面睡着了

与wait相似的是，sleep也是可中断方法（从方法签名能够看得出来，可能抛出InterruptedException），也就是说若是一个线程正在sleep，若是另外的线程将他中断（调用interrupt方法），将会抛出异常，而且中断状态将会擦除

因此对于sleep方法，要么本身醒来，要么被中断后也会醒来

对于sleep始终有一个超时时间的设置，因此，尽管他是在监视器内睡着了，可是并不会致使死锁，由于他终究是要醒来的

 

以下，线程休眠500毫秒，主线程50毫秒打印一次状态

ps：sleep方法的调用结果为状态：TIMED_WAITING

借助于sleep方法，能够模拟线程的顺序执行

好比下面示例，两个阶段，第二个阶段将在第一个阶段执行以后才会执行

package test1;
import java.lang.Thread.State;
public class T16 {
public static void main(String[] args) {
//模拟执行任务的第一个阶段的执行
Thread stepOne = new Thread(() -> {
System.out.println(Thread.currentThread().getName()+" : 第一阶段任务开始执行");
try {
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName()+" : 第一阶段任务执行结束");
} catch (InterruptedException e) {
}
}, "firstStage");
stepOne.start();
//模拟任务第二个阶段的执行
Thread stepTwo = new Thread(() -> {
while (!State.TERMINATED.equals(stepOne.getState())) {
try {
Thread.sleep(100);
System.out.println(Thread.currentThread().getName()+" : 我在等待第一阶段任务执行结束");
} catch (InterruptedException e) {
}
}
System.out.println(Thread.currentThread().getName()+" : 第二阶段任务执行结束");
}, "secondStage");
stepTwo.start();
}
}

另外，你应该已经注意到sleep方法都有static修饰，既然是静态方法，在Thread中的惯例就是针对于：当前线程，当前线程，当前线程

yield方法

对于sleep或者wait方法，他们都将进入特定的状态，伴随着状态的切换，也就意味着等待某些条件的发生，才可以继续，好比条件知足，或者到时间等

可是yield方法不涉及这些事情，他针对的是时间片的划分与调度，因此对开发者来讲只是临时让一下，让一下他又不会死，就只是再等等

yield方法将会暂停当前正在执行的线程对象，并执行其余线程，他始终都是RUNNABLE状态

不过要注意，能够认为yield只是一种建议性的，若是调用了yield方法，对CPU时间片的分配进行了“礼让”，他仍旧有可能继续得到时间片，而且继续执行

因此一次调用yield 并不必定会表明确定会发生什么

借助于while循环以及yield方法，能够看得出来，也能必定程度上达到线程排序等待的效果

yield也是静态方法，因此，也是针对于当前线程，当前线程，当前线程。

join方法

三个版本的join方法

方法的实现过程，与wait也是很是相似，下面两个版本的方法一个调用join（0）,一个参数校验后，调用join（millis），因此根本仍是单参数版本的join方法

在方法深刻介绍前先看个例子

一个线程，循环5次，每次sleep 1s，主线程中打印信息

从结果能够看到，主线程老是在线程执行以后，才会执行，也就是主线程在等待咱们建立的这个线程结束，结束了以后才会继续进行

若是调整下顺序--->start 与 join的前后顺序，再次看下状况，能够发现顺序没有保障了

结论：

主线程main中调用启动线程（调用start），而后调用该线程的join方法，能够达到主线程等待工做线程运行结束才执行的效果，而且join要在start调用后

如何作到的？

从上面源代码能够看得出来，内部调用了wait方法，因此也能明白为啥join也会抛出InterruptedException了吧

主线程main中调用thread.join（）方法，join方法至关于join（0），也就是

            while (isAlive()) {

                wait(0);

            }

而这个wait（0）就至关因而this.wait（0），this就是咱们本身建立的那个线程thread，看看方法的签名是否是有一个synchronized

isAlive（）也是this.isAlive（），也就是若是当前线程alive（已经启动，可是未终止），那么将持续等待，等待的临界资源就是咱们建立的这个线程对象自己

因此这两行代码的含义就是：

该线程是否还存活？若是存活，调用join的那个线程将会在这个对象上进行等待（进入该线程对象的等待集）

也就是说调用一个线程的join方法，就是在这个线程是等待，这个线程对象就是咱们的锁对象（不要疑惑，Object均可以做为锁，Thread实例对象怎么不能够？）

确定你们很奇怪，既然是等待，wait又不会本身醒来，那不是出问题了吗？

其实线程结束后，会调用this.notifyAll，因此主线程main会被唤醒

 

若是传递的参数不为0，将会走到下面的分支，会wait指定时长，与上面的逻辑一致，只不过是有指定超时时长而已

                long delay = millis - now;

                if (delay <= 0) {

                    break;

                }

                wait(delay);

                now = System.currentTimeMillis() - base;

 

手动版本的等待结束

只是将join方法换成了同步代码块，锁对象为那个线程的实例对象thread，调用他的wait方法

从结果上看，效果同样

（不过此处没有持续监测isAlive（），因此一旦主线程醒来，即便线程没有结束，也会继续，不能百分百确保main确定等待线程结束）

不过要注意：注释中有说明，本身不要使用Thread类的实例对象做为锁对象，若是是如今这种场景，使用join便可

为何？从咱们目前来看，join方法就是以这个对象为锁，若是你本身在使用，又是wait又是notify（notifyAll）的，万一出现什么隐匿的问题咋办？

因此join方法的原理就是：将指定的Thread实例对象做为锁对象，在其上进行同步，只要那个线程还活着，那么就会持续等待（或者有限时长）

线程终止以后会调用自身this.notifyAll，以通知在其上等待的线程

简单说，只要他活着你们就都等着， 他死了会通知，因此效果就是在哪里调用了谁的join，哪里就要等待这个线程结束，才能继续

为何要在start以后？

如上面所示，将join改形成同步代码块以下所示，若是这段同步代码在start方法以前

看下结果，没有等待指定线程结束，main主线程就结束了

由于若是尚未调用start方法，那么isAlive是false（已开始未结束），主线程根本就不会等待，因此继续执行，而后继续到下面的start，而后主线程结束

因此，为何join方法必定要在start以前？

就是由于这个isAlive方法的校验，你没有start，isAlive就是false，就不会同步等待，因此必需要先start，而后才能join

小结：

对于join方法，有两个关键：

• 调用的哪一个对象的join？
• 在哪里调用的？

换一个说法：
join的效果是：一个线程等待另外一个线程（直到结束或者持续一段时间）才执行，那么谁等待谁？

在哪一个线程调用，哪一个线程就会等待；调用的哪一个Thread对象，就会等待哪一个线程结束；

状态图回顾

在回顾下以前状态一文中的切换图，又了解了这几个方法后，应该对状态切换有了更全面的认识

总结

对于yield方法，比较容易理解，只是简单地对于CPU时间片的“礼让”，除非循环yield，不然一次yield，可能下次该线程仍旧可能会抢占到CPU时间片，可能方法调用和不调用没差异

sleep是静态方法，针对当前线程，进入休眠状态，两个版本的sleep方法始终有时间参数，因此必然会在指定的时间内苏醒，他也不会释放锁，固然，sleep方法的调用非必须在同步方法（同步代码块）内

join是实例方法，表示等待谁，是用于线程顺序的调度方法，能够作到一个线程等待另一个线程，join有三个版本，指定超时时间或者持续等待直到目标线程执行结束，join也无需在同步方法（同步代码块）内

sleep和join都是可中断方法，被其余线程中断时，都会抛出InterruptedException异常，而且会醒来

 

join方法底层依赖wait，咱们对比下wait与sleep 

• wait和sleep都会使线程进入阻塞状态，都是可中断方法，被中断后都会抛出异常
• wait是Object的方法，sleep是Thread的方法
• wait必须在同步中执行，sleep不须要（join底层依赖wait，可是不须要在同步中，由于join方法就是synchronized的）
• wait会释放锁，sleep不会释放锁
• wait（无超时设置的版本）会持续阻塞，必须等待唤醒，而sleep必然有超时，因此必定会本身醒来
• wait 实例方法（Object），在对象上调用，表示在其上等待；sleep静态方法，当前线程  

原文地址:sleep、yield、join方法简介与用法 多线程中篇（十四）