[Java多线程编程之二] 当初叫人家小甜甜，现在叫我牛夫人 —— 多变的线程状态

于 2019-10-13 23:53:54 发布
阅读量140 收藏 1
点赞数
分类专栏： 班级作业 文章标签： 网易云课堂-微专业Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hyh1123176978/article/details/102540240
版权

一、线程生命周期与状态

  一个线程从创建、运行到终止称为一个生命周期，线程在其生命周期中要经历创建、就绪、运行、阻塞、等待、终止多种状态，这多种状态的转换图如图所示：

  当一个线程对象被创建时，状态为New；当线程启动时，进入Runnable状态；当线程运行由于资源或锁被占用时，进入Blocked状态；当线程休眠时，进入等待状态；当线程执行完毕或发生中断异常是时，线程运行结束，进入Terminated状态。
  JDK的Thread类中定义了线程状态的内部枚举类State，如下所示：

    public enum State {
        NEW,
        RUNNABLE,
        BLOCKED,
        WAITING,
        TIMED_WAITING,
        TERMINATED;
    }

1、New

  当一个Thread类或其子类使用new关键字声明一个对象实例时，JVM为对象分配堆内存，此时线程处于新建状态，但是线程还没有被运行，即没有被激活。

2、Runnable

  处于新建状态的线程通过调用start方法启动后，线程进入就绪状态，这时的线程已经拥有了运行所需的所有条件，将进入线程队列排队等待CPU调度。由于还没有获得CPU时间片，所以启动后不会被立即执行；当获得CPU时间片后，线程由就绪状态转换为运行状态，处于运行状态的线程将执行run方法中定义的操作。
  当然，State枚举类中没有对这两个状态加以区分，我们也很难肉眼判断线程是就绪还是运行中，这依赖于操作系统对CPU的时间分片调度。

3、Blocked

  线程运行过程中可能由于某些原因让出正在使用的CPU资源，进入阻塞（Blocked）状态，这些情况包括：

  • 某些共享资源（如打印机或文件资源等）被占用；
  • 等待IO操作；
  • 调用了suspend等方法；
  • 尝试获得锁，而该锁正在被其他线程持有。

  为了提高CPU的使用率，当一个线程被阻塞时，另一个线程就获得了运行的机会。当阻塞的原因被消除后，线程将进入就绪状态等待继续执行。

4、Waiting

  当线程遇到下面的情况时会进入等待（Waiting）状态，包括：

  • 调用wait方法，等待其他线程通知；
  • 调用park方法，等待其他线程调用unpark()释放许可证。

5、Timed Waiting

  当线程遇到下面情况时会进入超时等待（Timed Waiting）状态，包括：

  • 调用sleep方法；
  • 调用带超时时间的park方法。

6、Terminated

  当线程遇到下面的情况时会进入终止（Terminated）状态，包括：

  • 线程的run方法执行结束；
  • 线程通过某些方法（例如Destory()）被提前终止；
  • 在run方法的执行期间发生了未捕获的异常
  • 程序的终止操作（如调用System.exit）

二、实例演示

  常见的线程转态切换有以下几种：

1、新建 -> 运行 -> 结束

  当线程被创建时，进入新建状态；
  当线程启动时，进入运行状态；
  当run方法体执行结束时，进入终止状态。

代码示例如下：

public class Demo2 {
	public static void main(String[] args) throws Exception {
		// 第一种状态切换: 新建 -> 运行 -> 终止
		System.out.println("####### 第一种状态切换: 新建 -> 运行 -> 终止 #######");
		Thread thread1 = new Thread(new Runnable() {
			@Override
			public void run() {
				System.out.println("thread1当前状态: " + Thread.currentThread().getState().toString());
				System.out.println("thread1执行了");
			}
		});
		System.out.println("没调用start方法，thread1当前状态: " + thread1.getState().toString());
		thread1.start();
		Thread.sleep(2000L);   // 主线程休眠两秒，让thread1执行结束后，再看其状态
		System.out.println("等待两秒，再看thread1当前状态: " + thread1.getState().toString());
		System.out.println();
        // thread1.start();   // 注意: 线程终止后，再调用start方法，会抛出IllegalThreadStateException异常
   }
}

运行结果：

####### 第一种状态切换: 新建 -> 运行 -> 终止 #######
没调用start方法，thread1当前状态: NEW
thread1当前状态: RUNNABLE
thread1执行了
等待两秒，再看thread1当前状态: TERMINATED

[注意] 当线程结束时，再次启动线程会抛出IllegalThreadStateException异常

2、新建 -> 运行 -> 等待（超时）-> 运行 -> 结束

  当线程被创建时，进入新建状态
  当线程被启动时，进入运行状态
  当调用sleep/park（带超时时间）方法是，进入等待（超时）状态
  当线程休眠结束或者拿到许可证时，重新进入运行状态
  当run方法体执行结束时，进入终止状态。

代码示例如下：

public class Demo2 {
	public static void main(String[] args) throws Exception {
		// 第二种状态切换: 新建 -> 运行 -> 等待(超时) -> 运行 -> 终止 (通过线程休眠切换到等待状态)
		System.out.println("####### 第二种状态切换: 新建 -> 运行 -> 等待(超时) -> 运行 -> 终止  #######");
		Thread thread2 = new Thread(new Runnable() {			
			@Override
			public void run() {
				try {    // 将线程移动到等待状态，1500ms后自动唤醒
					Thread.sleep(1500);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("thread2当前状态: " + Thread.currentThread().getState().toString());
				System.out.println("thread2 执行了");
			}
		});
		System.out.println("没调用start方法，thread2当前状态: " + thread2.getState().toString());
		thread2.start();
		System.out.println("调用start方法，thread2当前状态: " + thread2.getState().toString());
		Thread.sleep(200L);   // 等待200ms，再看状态
		System.out.println("等待200毫秒，再看thread2当前状态: " + thread2.getState().toString());
		Thread.sleep(3000L);  // 再等待3秒，让thread2执行完毕，再看状态
		System.out.println("等待3秒，再看thread2当前状态: " + thread2.getState().toString());
		System.out.println();
    }
}

运行结果：

####### 第二种状态切换: 新建 -> 运行 -> 等待 -> 运行 -> 终止  #######
没调用start方法，thread2当前状态: NEW
调用start方法，thread2当前状态: RUNNABLE
等待200毫秒，再看thread2当前状态: TIMED_WAITING
thread2当前状态: RUNNABLE
thread2 执行了
等待3秒，再看thread2当前状态: TERMINATED

3、新建 -> 运行 -> 等待（通知/许可）-> 运行 -> 结束

  当线程被创建时，进入新建状态
  当线程被启动时，进入运行状态
  当调用wait/park方法是，进入等待（通知/许可）状态
  当线程收到通知或者拿到许可证时，重新进入运行状态
  当run方法体执行结束时，进入终止状态。

代码如下：

public class Demo2 {
	public static void main(String[] args) throws Exception {
		// 第四种状态切换: 新建 -> 运行 -> 等待(通知) -> 运行 -> 终止
		System.out.println("####### 第四种状态: 新建 -> 运行 -> 等待(通知) -> 运行 -> 终止  #######");
		Thread thread4 = new Thread(new Runnable() {			
			@Override
			public void run() {
				try {
					synchronized (Demo2.class) {
						Demo2.class.wait();
					}
					System.out.println("thread4收到通知，当前状态: " + Thread.currentThread().getState().toString());
				} catch (InterruptedException e) {					
					e.printStackTrace();
				}
				
			}
		});
		System.out.println("没调用start方法，thread4当前状态: " + thread4.getState().toString());
		thread4.start();
		System.out.println("调用start方法，thread4当前状态: " + thread4.getState().toString());
		Thread.sleep(200L);  // 等待200ms，再看状态
		System.out.println("等待200毫秒，再看thread4当前状态: " + thread4.getState().toString());
		synchronized (Demo2.class) {
			Demo2.class.notifyAll();
		}
		Thread.sleep(3000L);  // 再等待3秒，让thread3执行完毕，再看状态
		System.out.println("等待3秒，让thread4执行结束，再看thread4当前状态: " + thread4.getState().toString());
		System.out.println();	
    }
}

运行结果：

####### 第四种状态: 新建 -> 运行 -> 等待 -> 运行 -> 终止  #######
没调用start方法，thread4当前状态: NEW
调用start方法，thread4当前状态: RUNNABLE
等待200毫秒，再看thread4当前状态: WAITING
thread4收到通知，当前状态: RUNNABLE
等待3秒，让thread4执行结束，再看thread4当前状态: TERMINATED

4、新建 -> 运行 -> 阻塞 -> 运行 -> 结束

  当线程被创建时，进入新建状态
  当线程被启动时，进入运行状态
  当线程等待获取锁或其他资源时，进入阻塞状态
  当线程拿到了锁或阻塞的资源时，重新进入运行状态
  当run方法体执行结束时，进入终止状态。

代码如下：

public class Demo2 {
	public static void main(String[] args) throws Exception {
		// 第三种状态切换: 新建 -> 运行 -> 阻塞 -> 运行 -> 终止 (通过线程抢锁切换到阻塞状态)
		System.out.println("####### 第三种状态切换: 新建 -> 运行 -> 阻塞 -> 运行 -> 终止  #######");
		Thread thread3 = new Thread(new Runnable() {			
			@Override
			public void run() {
				synchronized (Demo2.class) {
					System.out.println("thread3当前状态: " + Thread.currentThread().getState().toString());
					System.out.println("thread3 执行了");					
				}
			}
		});
		synchronized (Demo2.class) {
			System.out.println("没调用start方法，thread3当前状态: " + thread3.getState().toString());
			thread3.start();
			System.out.println("调用start方法，thread3当前状态: " + thread3.getState().toString());
			Thread.sleep(200L);  // 等待200ms，再看状态
			System.out.println("等待200毫秒，再看thread3当前状态: " + thread3.getState().toString());
		}
		Thread.sleep(3000L);  // 再等待3秒，让thread3执行完毕，再看状态
		System.out.println("等待3秒，让thread3抢到锁，再看thread3当前状态: " + thread3.getState().toString());
		System.out.println();
    }
}

结果如下：

####### 第三种状态切换: 新建 -> 运行 -> 阻塞 -> 运行 -> 终止  #######
没调用start方法，thread3当前状态: NEW
调用start方法，thread3当前状态: RUNNABLE
等待200毫秒，再看thread3当前状态: BLOCKED
thread3当前状态: RUNNABLE
thread3 执行了
等待3秒，让thread3抢到锁，再看thread3当前状态: TERMINATED
scau-codeman
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值