线程的六种状态
- (1) NEW(初始状态)
- (2) TERMINATED(终止状态 / 死亡状态)
- (3) RUNNABLE(运行时状态)
- (4) TIMED_WAITING(超时等待状态)
- (5) WAITING(等待状态)
- (6) BLOCK(阻塞状态)
- sleep和wait的区别:
操作系统里的线程自身是有一个状态的,但是java Thread 是对系统线程的封装,把这里的状态又进一步细化了~~
| 状态 | 说明 |
|---|---|
| NEW | 线程还没有创建,但是线程对象已经创建出来了 |
| TERMINATED | 线程结束了,但是线程对象还存在 |
| RUNNABLE | 就绪状态,可以细分为两个状态 |
| TIMED_WAITING | 指超时等待状态 |
| BLOCK | 等待状态 |
| WAITING | 表示阻塞时出现的状态 |
下面将通过代码运行结果来带大家细致了解线程运行的状态.
(1) NEW(初始状态)
public static void main(String[] args) {
Thread t = new Thread(()->{
System.out.println("t 线程");
});
//获取线程的状态
System.out.println("当前线程是 " +t.getState() + "状态");
//调用start(),创建这个线程
t.start();
}
NEW状态指的是 : 线程在刚刚被new出来的时候,还没有调用start()的状态.
此时可以称这个状态为: (1) 初始状态 (2) 创建状态
运行结果:
(2) TERMINATED(终止状态 / 死亡状态)
public static void main(String[] args) {
Thread t = new Thread(()->{
System.out.println("t 线程");
});
//调用start(),创建这个线程
t.start();
try {
//由于计算机的执行速度是很快的,所以1000ms足够t线程执行完
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//获取线程的状态
System.out.println("当前线程是 " +t.getState() + "状态");
t.start();
}
如果一个线程的 run() 方法执行结束 该线程就会死亡,对于已经死亡的线程,无法再使用 start() 方法令其进入就绪.
运行结果:
(3) RUNNABLE(运行时状态)
运行时状态可以细分为两个状态:(1) 正在运行状态RUNNING (2) 就绪状态READY
我们可以这么理解 :
(1) 例如我女朋友下班了,我正在带我女朋友去吃饭,此时就是正在运行状态.
(2)因为我提前下班了,但是我女朋友还没有下班,所以此时我在女朋友公司门口等她,只要她下班我随时可以带她吃饭去,此时我就是就绪状态.
通过代码实现(1) :
public static void main(String[] args) {
Thread t = new Thread(()->{
while(true){
//什么都不打印,防止把下面的打印信息冲走
}
});
//调用start(),创建这个线程
t.start();
//运行线程时判断此时的状态
System.out.println("当先线程是 "+t.getState()+"状态");
}
由于此时的 t 线程一直在执行死循环,所以 t 线程的状态是正在运行的~~
运行结果:
(4) TIMED_WAITING(超时等待状态)
可以理解为,具有指定等待时间的,正在等待(阻塞)线程的线程状态,由于调用具有指定等待时间的以下方法之一,线程处于定时等待状态.
具有指定等待时间的方法:
(1) Thread.sleep(参数)指定时间,单位为ms
该方法会让当前线程暂停一段时间，其他线程有机会获得 CPU 时间片。
(2) t.join(参数)
调用 t.join 的线程需要等待线程 t 执行指定时间后,才可以运行,等待的过程中是处于阻塞状态的.
(3) wait(参数) :wait 方法提供一个带有 timeout 参数的版本, 来指定等待时间.超过这个时间之后无需其他线程调用该对象的 notify() 或 notifyAll() 方法唤醒该线程,该线程自己就会唤醒.
代码实现(1)
public static void main(String[] args) {
Thread t = new Thread(()->{
try {
//睡眠1000ms
Thread.sleep(1000);
System.out.println("hello t");
} catch (InterruptedException e) {
e.printStackTrace();
}
});
//调用start(),创建这个线程
t.start();
try {
//等待1000ms,此时t线程就创建结束,系统自动执行run方法里面的逻辑
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
//运行线程时判断此时的状态
System.out.println("当先线程是 "+t.getState()+"状态");
}
运行结果:
代码实现(2)
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(()->{
while (true){
try {
//每500ms打印一次
Thread.sleep(500);
System.out.println("t1");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
});
Thread t2 = new Thread(()->{
try {
//等待t1线程执行完1000ms
//t2线程再开始执行
t1.join(1000);
System.out.println("t2");
} catch (InterruptedException e) {
e.printStackTrace();
}
});
//创建t1线程
t1.start();
//创建t2线程
t2.start();
//等待500ms此时两个线程都创建完毕
Thread.sleep(500);
System.out.println("当先线程是 "+t2.getState()+"状态");
}
运行结果:
代码实现(3)
public class ThreadDemo8 {
//自己指定的锁对象
static Object object = new Object();
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(()->{
//两个锁对象相同
synchronized (object){
for (int i = 0; i < 10; i++) {
if(i == 5) {
try {
object.wait(1000);
//虽然过了1000ms,但是还是需要等待t2线程中锁里面的程序执行完
// 才可以继续执行锁.(这里是指,仅有两个锁,且锁对象相等的情况)
} catch (InterruptedException e) {
e.printStackTrace();
}
}
System.out.println(i);
}
}
});
Thread t2 = new Thread(()->{
//两个锁对象相同
synchronized (object){
for (int i = 0; i <10 ; i++) {
try {
System.out.println("t2");
Thread.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
//t1线程先创建
t1.start();
//等待100ms是防止t2先抢到锁
Thread.sleep(100);
//创建t2线程
t2.start();
//查看当前线程的状态
System.out.println("当先线程是 "+t1.getState()+"状态");
}
}
运行结果:
(5) WAITING(等待状态)
处于这种状态的线程不会被CPU分配执行时间，他们要等待的显示被唤醒，否则会处于无限期的等待状态
具有阻塞的方法:
(1)使用 Thread.join() 方法。该方法会让当前线程等待另一个线程终止
(2) 使用 Object.wait() 方法。该方法会让当前线程等待,直到其他线程调用该对象的 notify() 或 notifyAll() 方法唤醒该线程。
我们这里只演示第一种就好~
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(()->{
while (true){
}
});
Thread t2 = new Thread(()->{
try {
t1.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
},"猪猪侠");
//创建这t1线程
t1.start();
//等待200ms让t1线程优先创建好
Thread.sleep(200);
//创建这t2线程
t2.start();
//等待200ms让t2线程优先创建好
Thread.sleep(200);
System.out.println("当先线程 "+t2.getName()+"的状态是"+t2.getState()+"状态");
}
运行结果是:
(6) BLOCK(阻塞状态)
阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃cpu的使用权，暂停或停止运行，直到线程进入就绪状态，才有机会获得cpu的青睐从而转入运行状态。
我们可以通俗点理解为~ 等待锁的状态.
例如: t1 和 t2 需要的锁对象相同,如果此时 t1 拿到了锁,当 t2 执行到进入锁的代码的时候, t2 就需要等 t1 释放锁之后才可以拿到这把锁.
我们通过代码演示:
public class ThreadDemo8 {
static Object object = new Object();
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(()->{
//两个锁对象相同
synchronized (object){
while (true){
}
}
});
Thread t2 = new Thread(()->{
//两个锁对象相同
//由于先执行的t1所以需要等t1释放锁才可以执行t2
//此时t2处于阻塞状态
synchronized (object){
System.out.println("t2");
}
},"猪猪侠");
//创建这t1线程
t1.start();
//等待200ms让t1线程优先创建好
Thread.sleep(200);
//创建这t2线程
t2.start();
//等待200ms让t2线程优先创建好
Thread.sleep(200);
//查看t2线程的状态
System.out.println("当先线程 "+t2.getName()+"的状态是"+t2.getState()+"状态");
}
}
运行结果:
关于线程状态的关系图:
sleep和wait的区别:
sleep()和wait()方法有什么区别：
sleep()睡眠时，保持对象锁，仍然占有该锁；
而wait()睡眠时，释放对象锁。
但是wait()和sleep()都可以通过interrupt()方法打断线程的暂停状态，从而使线程立刻抛出InterruptedException（但不建议使用该方法）。
