线程的生命周期可以大致分为5种,但这种说法是比较旧的一种说法,有点过时了,或者更确切的来说,这是操作系统的说法,而不是java的说法。但对下面所说的六种状态的理解有所帮助,所以也写出来,作为参考。
1. NEW: 线程的新建状态,是指通过New关键字创建了Thread类(或其子类)的对象。
2. RUNNABLE: 这种情况指的是Thread类的对象调用了start()方法,这时的线程就等待时间片轮转到自己这,以便获得CPU;第二种情况是线程在处于RUNNABLE状态时并没有运行完自己的run方法,时间片用完之后回到RUNNABLE状态;还有种情况就是处于BLOCKED状态的线程结束了当前的BLOCKED状态之后重新回到RUNNABLE状态。
3. RUNNING: 这时的线程指的是获得CPU的RUNNABLE线程,RUNNING状态是所有线程都希望获得的状态。
4. DEAD: 处于RUNNING状态的线程,在执行完run方法之后,或者异常退出时,就变成了DEAD状态了。
5. BLOCKED: 这种状态指的是处于RUNNING状态的线程,出于某种原因,比如调用了sleep方法、等待用户输入等而让出当前的CPU给其他的线程。
注意: BLOCKED状态,包括三种类型状态:等待(wait)、睡眠(sleep)、阻塞(申请资源:I\O、对象的锁);
在java中,线程的状态其实是六种,对应着枚举类型 Thread.State 的六个枚举常量:NEW
、BLOCKED
、RUNNABLE
、WAITING
、TIMED_WAITING
、TERMINATED
1. NEW : 新建状态,至今尚未启动的线程的状态。
1 static void NEW() {
2 Thread t = new Thread ();//也就是可以理解为刚刚创建thread
3 System. out.println(t.getState());
4 }
2. BLOCKED: 阻塞状态,受阻塞并且正在等待监视器锁的某一线程的线程状态。
1private static void BLOCKED() {
2 final Object lock = new Object();
3 Runnable run = new Runnable() {
4 @Override
5 public void run() {
6 for(int i=0; i<Integer.MAX_VALUE; i++){
7 synchronized (lock) {
8 System. out.println(i);
9 }
10 }
11 }
12 };
13 Thread t1 = new Thread(run);
14 t1.setName( “t1”);
15 Thread t2 = new Thread(run);
16 t2.setName( “t2”);
17 t1.start();
18 t2.start();
19 }
3. RUNNABLE: 可运行线程的线程状态。这里其实合并了两种状态(RUNNING、RUNABLE)
1private static void RUNNABLE() {
2 Thread t = new Thread(){
3 public void run(){
4 for(int i=0; i<Integer.MAX_VALUE; i++){
5 System. out.println(i);
6 }
7 }
8 };
9 t.start();
10 }
当线程调用了start()方法之后,就是运行状态了。
4. WAITING : 等待状态,表示线程进入状态。进入此状态后,会无限等待,直到其他线程做出一些特定的动作(唤醒通知、中断通知)才会再次运行。
1 private static void WAITING() {
2 final Object lock = new Object();
3 Thread t1 = new Thread(){
4 @Override
5 public void run() {
6 int i = 0;
7 while(true ){
8 synchronized (lock) {
9 try {
10 lock.wait();//调用这个方法,进入等待状态
11 } catch (InterruptedException e) {
12 }
13 System. out.println(i++);
14 }
15 }
16 }
17 };
18 Thread t2 = new Thread(){
19 @Override
20 public void run() {
21 while(true ){
22 synchronized (lock) {
23 for(int i = 0; i< 10000000; i++){
24 System. out.println(i);
25 }
26 lock.notifyAll();
27 }
28 }
29 }
30 };
31 t1.setName( “^^t1^^”);
32 t2.setName( “^^t2^^”);
33 t1.start();
34 t2.start();
35 }
5. TIMED_WAITING : 计时等待状态,此状态与 WAITING 状态有些类似,但它是有时间限制的,即只会等待一段指定的时间,当时间到来前,没有被唤醒或或中断,那么时间到来了,就自动"醒来",进入RUNNABLE状态。
1synchronized (lock) {
2 try {
3 lock.wait(60 * 1000L);//只会等待一段指定的时间,当时间到来前,没有被唤醒或或中断
4 } catch (InterruptedException e) {
5 }
6 System. out .println(i++);
7 }
6. TERMINATED : 终止状态,已终止线程的线程状态。
1 private static void TERMINATED() {
2 Thread t1 = new Thread();
3 t1.start();
4 System. out.println(t1.getState());
5 try {
6 Thread. sleep(1000L);
7 } catch (InterruptedException e) {
8 }
9 System. out.println(t1.getState());
10 }
图片来源网络,如有侵权,删