前言：线程的五种状态

本文是线程篇的一个分支,主要结合我的理解,看一下sleep和wait以及线程的一些状态
网上的图看起来都有点丑，我自己画了一幅:

1.New：       新建态:  new Thread ~ thread.start期间
2.Runnable：  可执行态: 可被CPU调度执行期间。
3.Running     运行态: 线程获取CPU权限进行执行
4.Blocked     阻塞状态: 阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。|---等待阻塞:通过调用线程的wait()方法，让线程等待某工作的完成。|---同步阻塞:线程在获取synchronized同步锁失败(因为锁被其它线程所占用)时|---其他阻塞:通过调用线程的sleep()或join()或发出了I/O请求时
5.Dead        死亡状态: 线程执行完了或者因异常退出了run()方法，该线程结束生命周期。
复制代码

一、Thread.sleep简述

暂停当前线程，进入Blocked状态,把cpu片段让出给其他线程。

1.测试代码：

public class Main0 {static SimpleDateFormat sdf = new SimpleDateFormat("mm:ss");public static void main(String[] args) {new Thread(new Car()).start();try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}new Thread(new Ambulance()).start();}private static class Car implements Runnable {@Overridepublic void run() {System.out.println(sdf.format(System.currentTimeMillis()) + ":小汽车开始启动,在路上跑");System.out.println(sdf.format(System.currentTimeMillis()) + ":小汽车跑到终点");}}private static class Ambulance implements Runnable {@Overridepublic void run() {System.out.println(sdf.format(System.currentTimeMillis()) + ":救护车开始启动,在路上跑");System.out.println(sdf.format(System.currentTimeMillis()) + ":救护车跑到终点");}}
}
复制代码

2. 结果分析：注02:29代表当前时刻的分秒，即2分29秒

---->[运行结果]----------------------
02:29:小汽车开始启动,在路上跑
02:29:小汽车跑到终点
02:31:救护车开始启动,在路上跑
02:31:救护车跑到终点
复制代码

二、线程内sleep以及synchronized

1.子线程加入休眠

private static class Car implements Runnable {@Overridepublic void run() {System.out.println(sdf.format(System.currentTimeMillis()) + ":小汽车开始启动,在路上跑");try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(sdf.format(System.currentTimeMillis()) + ":小汽车跑到终点");}
}
复制代码

2.结果分析

Car线程的任务是睡5s,可见主线程的休眠没有影响到Car子线程的运行(休眠)

18:48:小汽车开始启动,在路上跑
18:50:救护车开始启动,在路上跑
18:50:救护车跑到终点
18:53:小汽车跑到终点
复制代码

3.当加锁睡眠时

在线程1中加synchronized(这里锁用sdf对象,你也可以任意)

public class Main2 {static SimpleDateFormat sdf = new SimpleDateFormat("mm:ss");public static void main(String[] args) {new Thread(new Car()).start();try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}new Thread(new Ambulance()).start();}private static class Car implements Runnable {@Overridepublic void run() {synchronized (sdf){System.out.println(sdf.format(System.currentTimeMillis()) + ":小汽车开始启动,在路上跑");try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(sdf.format(System.currentTimeMillis()) + ":小汽车跑到终点");}}}private static class Ambulance implements Runnable {@Overridepublic void run() {synchronized (sdf){System.out.println(sdf.format(System.currentTimeMillis()) + ":救护车开始启动,在路上跑");System.out.println(sdf.format(System.currentTimeMillis()) + ":救护车跑到终点");}}}
}
复制代码

2.结果分析

Car线程和Ambulance线程在运行时使用同一把锁,线程在休眠时不会释放锁
所以Ambulance线程需要等待Car线程执行完成,才能进行执行

23:46:小汽车开始启动,在路上跑
23:51:小汽车跑到终点
23:51:救护车开始启动,在路上跑
23:51:救护车跑到终点
复制代码

三、Object#wait()方法的作用

在线程t1调用A对象的wait()方法,会释放t1持有的锁，让t1进入等待队列(Blocked状态)
直到其他线程调用A对象的notify()方法或notifyAll()方法t1进入同步队列(Blocked状态)
当t1获得锁后会进入就绪状态Runnable,获取CPU的调度权后会继续执行,再贴一遍这个图:

1.wait方法的使用

既然是释放当前线程的锁，那么不须有锁才行，而且必须用该锁的对象调用wait方法
比如上面是用sdf对象加锁的,必须使用sdf.wait();,否则会抛出InterruptedException

private static class Car implements Runnable {@Overridepublic void run() {synchronized (sdf) {System.out.println(sdf.format(System.currentTimeMillis()) + ":小汽车开始启动,在路上跑");try {Thread.sleep(3000);//模拟执行3s的任务之后} catch (InterruptedException e) {e.printStackTrace();}try {System.out.println(sdf.format(System.currentTimeMillis()) + ":小汽车紧急刹车....");sdf.wait();System.out.println(sdf.format(System.currentTimeMillis()) + ":小汽车开始启动....");} catch (InterruptedException e) {e.printStackTrace();}try {Thread.sleep(5000);} catch (InterruptedException e) {e.printStackTrace();}System.out.println(sdf.format(System.currentTimeMillis()) + ":小汽车跑到终点");}}
}
private static class Ambulance implements Runnable {@Overridepublic void run() {synchronized (sdf) {System.out.println(sdf.format(System.currentTimeMillis()) + ":救护车开始启动,在路上跑");System.out.println(sdf.format(System.currentTimeMillis()) + ":救护车跑到终点");}}
}
复制代码

2.结果分析

在Car线程调用sdf.wait();后,锁将被释放，然后Ambulance线程就可以持有锁运行了
如果不唤醒线程，线程将一直阻塞，就是根本停不下来。打个比方就是sdf是司机
wait()之后就把车钥匙扔了，然后熄火了。钥匙拿不回来，车就跑不了。需要notify()获取车钥匙

30:48:小汽车开始启动,在路上跑
30:51:小汽车紧急刹车....
30:51:救护车开始启动,在路上跑
30:51:救护车跑到终点
然后就阻塞在这里停不下来了....
复制代码

3.唤醒等待线程

注意wait和notify需要使用同一个对象,否则然并卵
在Ambulance线程跑完后唤醒Car线程,然后Car获取所后会进入就绪态

private static class Ambulance implements Runnable {@Overridepublic void run() {synchronized (sdf) {System.out.println(sdf.format(System.currentTimeMillis()) + ":救护车开始启动,在路上跑");System.out.println(sdf.format(System.currentTimeMillis()) + ":救护车跑到终点");sdf.notify();}}
}
复制代码

4.结果分析

40:23:小汽车开始启动,在路上跑
40:26:小汽车紧急刹车....
40:26:救护车开始启动,在路上跑
40:26:救护车跑到终点
40:26:救护车:喂，哥们,醒醒,你可以开了...
40:26:小汽车开始启动....
40:31:小汽车跑到终点
复制代码

四、Thread#join()方法 和Thread#yield

1.普通代码

public class Main6 {static SimpleDateFormat sdf = new SimpleDateFormat("mm:ss");public static void main(String[] args) {Thread car = new Thread(new Car());car.start();System.out.println(sdf.format(System.currentTimeMillis()) + ":main线程结束");}private static class Car implements Runnable {@Overridepublic void run() {System.out.println(sdf.format(System.currentTimeMillis()) + ":小汽车开始启动,在路上跑");try {Thread.sleep(3000);//模拟执行3s的任务之后} catch (InterruptedException e) {e.printStackTrace();}System.out.println(sdf.format(System.currentTimeMillis()) + ":小汽车跑到终点");}}
}
复制代码

2.结果分析

26:28:小汽车开始启动,在路上跑
26:28:main线程结束
26:31:小汽车跑到终点
复制代码

3.join方法的使用

阻塞当前线程,知道join的线程结束或超时

public class Main6 {static SimpleDateFormat sdf = new SimpleDateFormat("mm:ss");public static void main(String[] args) {Thread car = new Thread(new Car());car.start();try {car.join();} catch (InterruptedException e) {e.printStackTrace();}System.out.println(sdf.format(System.currentTimeMillis()) + ":main线程结束");}private static class Car implements Runnable {@Overridepublic void run() {System.out.println(sdf.format(System.currentTimeMillis()) + ":小汽车开始启动,在路上跑");try {Thread.sleep(3000);//模拟执行3s的任务之后} catch (InterruptedException e) {e.printStackTrace();}System.out.println(sdf.format(System.currentTimeMillis()) + ":小汽车跑到终点");}}
}
---->[打印结果]-----------------------------
31:53:小汽车开始启动,在路上跑
31:56:小汽车跑到终点
31:56:main线程结束
复制代码

4.yield方法测试

让出线程的cpu调度权,之后再一起抢夺。运行状态-->就绪状态

public class Main7 {public static void main(String[] args) {Thread car = new Car("car");Thread ambulance = new Car("Ambulance");car.start();ambulance.start();}private static class Car extends Thread {public Car(String name) {super(name);}@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(getName() + "----" + i);if (i == 5) {yield();}}}}
}
复制代码

运行了几组数据,大部分满足让出调度权后，另一个线程执行，也有少量情况不是。
所以yield说明我现在不急,可以划划水,执行权可以让出去。不过接下来谁执行还是不定的。

五、小结

1.需要补充的点:

1.关于synchronized锁这里不展开,不了解的可以见:线程篇3：[-synchronized-]
2.关于synchronized锁对象需要一致,否则锁不住，然并卵。常用class对象,如Car.class
3.可以设置超时唤醒xxx.wait(3000),即3s后唤醒线程。
4.可以设置join超时xxx.join(3000),即3s后线程进入就绪态。
5.notifyAll:来着黑暗寒冬的随从们,仆人们,士兵们,听从克尔苏加德的召唤吧!

2.简单比较