Java线程的6种状态与生命周期


Posted in Java/Android onMay 11, 2022

1.线程状态(生命周期)

一个线程在给定的时间点只能处于一种状态。

线程可以有如下6 种状态:

  • New (新创建):未启动的线程;
  • Runnable (可运行):可运行的线程,需要等待操作系统资源;
  • Blocked (被阻塞):等待监视器锁而被阻塞的线程;
  • Waiting (等待):等待唤醒状态,无限期地等待另一个线程唤醒;
  • Timed waiting (计时等待):在指定的等待时间内等待另一个线程执行操作的线程;
  • Terminated (被终止):已退出的线程。

要确定一个线程的当前状态, 可调用getState 方法

线程状态关系图

注意:虚线框(全大写英文)的状态为Java线程状态。

Java线程的6种状态与生命周期

2.操作线程状态

2.1.新创建状态(NEW)

就是实例化线程完成后,未启动线程的状态。

可通过三种方式创建线程

  • 重写Thread类run()方法
  • 实现Runnable接口
  • 实现Callable接口

一个简单的例子概括三种方式

public class Demo {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        /**
         * 1.直接重写run() 或继承Thread类再重写run()
         */
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("Thread");
            }
        };
        // 开启线程
        thread.start();

        /**
         * 2.lambda、内部类或线程类方式实现Runnable接口,实现run()方法
         * 再交给Thread 类
         */
        Thread runThread = new Thread(() -> {
            System.out.println("Runnable");
        });
        // 开启线程
        runThread.start();

        /**
         * 3.lambda、内部类或线程类方式实现Callable接口,实现call()方法
         * 再交给Thread 类:FutureTask本质也是Runnable实现类
         */
        FutureTask<String> futureTask = new FutureTask<String>(() -> {
            System.out.println("Callable");
            return "CallableThread";
        });
        Thread callThread = new Thread(futureTask);
        // 开启线程
        callThread.start();
        // 获取call()方法的返回值
        String s = futureTask.get();
        System.out.println("call()方法的返回值:"+s);
    }

}

不重写 run() 或 call() 方法直接实例化Thread类创建的线程没有实际意义;

只有Callable方式创建的线程可以获取线程的返回值。

2.2.可运行状态(RUNNABLE)

该状态指的是线程实例化对象调用start()方法后进入的状态。线程处于可以运行状态,如果有处理器等资源,就可以执行程序。

该状态在操作系统层面包含两步:线程就绪和线程运行中,但在Java线程状态中,这两步都统称为Runnable(可运行)状态。

线程由就绪状态变为运行状态,重点就看你的线程有没有抢到CPU资源(CPU时间片),谁抢到就运行,没抢到就等。因为CPU时间片(执行时间)非常短,大概十几毫秒,所以线程切换的这个时间是非常短的,就绪状态变为运行状态的时间也非常短,在开发时几乎感觉不到这种状态的变化,所以在Java中将两者看作是一个整体,重点关注线程可否运行并区别于其他状态即可,更进一步简化线程的开发。如果你的程序要运行很久(比如写个死循环),在一个CPU时间片内没有执行完成,那么你的线程就要抢下一次的CPU时间片,抢到了才可以继续执行程序,没抢到那就要继续抢,直到线程中的程序执行完成。

其实这个场景应该都见到过,例如多个线程执行同一个程序,都将日志打印到同一个文件时,就会出现不同线程的日志混在了一起的情况,不利于排查问题。解决这种问题常见的方法有:一是分线程打印日志到不同文件;二是将日志信息保存到字符串对象中,在程序的最后将日志信息一次性打印到文件。第二种方式就是利用CPU的一个时间片来完成日志信息的打印。

注意:程序只能对新建状态的线程调用start()方法,不要对处于非新建状态的线程调用start() 方法,这都会引发IllegalThreadStateException异常。

2.3.被阻塞状态(BLOCKED)

线程处于等待监视器而被阻塞的状态。有一个线程获取了锁未释放,其他线程也来获取,但发现获取不到锁也进入了被阻塞状态。

被阻塞状态只存在于多线程并发访问下,区别于后面两种因线程自己进入”等待“而导致的阻塞。

进入状态

  • 进入synchronized 代码块/方法
  • 未获取到锁

退出状态

  • 获取到监视器锁

2.4.等待唤醒状态(WAITING)

整个流程是这样的:线程在某个对象的同步方法中先获取到对象锁;在执行wait方法时,该线程将释放对象锁,并且该线程被放入到这个对象的等待队列;等待另一个线程获取到同一个对象的锁,然后通过notify() 或 notifyAll() 方法唤醒对象等待队列中的线程。

从整个流程可以知道

wait (),notify () 和 notifyAll () 方法需要在线程获取到锁的情况下才可以继续执行,所以这三个方法都需要放在同步代码块/方法中执行,否则报异常:java.lang.IllegalMonitorStateException。

在同步代码块中,线程进入WAITING 状态时,锁会被释放,不会导致该线程阻塞。反过来想下,如果锁没释放,那其他线程就没办法获取锁,也就没办法唤醒它。

进入状态

  • object.wait()
  • thread.join()
  • LockSupport.park()

退出状态

  • object.notify()
  • object.notifyall()
  • LockSupport.unpark()

2.5.计时等待状态(TIMED_WAITING)

一般是计时结束就会自动唤醒线程继续执行后面的程序,对于Object.wait(long) 方法还可以主动通知唤醒。

注意:Thread类下的sleep() 方法可以放在任意地方执行;而wait(long) 方法和wait() 方法一样,需要放在同步代码块/方法中执行,否则报异常:java.lang.IllegalMonitorStateException。

进入状态

  • Thread.sleep(long)
  • Object.wait(long)
  • Thread.join(long)
  • LockSupport.parkNanos(long)
  • LockSupport.parkNanos(Object blocker, long nanos)
  • LockSupport.parkUntil(long)
  • LockSupport.parkUntil(Object blocker, long deadline)

注:blocker 参数为负责此线程驻留的同步对象。

退出状态

  • 计时结束
  • LockSupport.unpark(Thread)
  • object.notify()
  • object.notifyall()

2.6.终止(TERMINATED)

线程执行结束

  • run()/call() 执行完成
  • stop()线程
  • 错误或异常>>意外死亡

stop() 方法已弃用。

3.查看线程的6种状态

通过一个简单的例子来查看线程出现的6种状态。

案例

public class Demo3 {
    private static Object object ="obj";
    
    public static void main(String[] args) throws InterruptedException {

        Thread thread0 = new Thread(() -> {
            try {
                // 被阻塞状态(BLOCKED)
                synchronized (object){
                    System.out.println("thread0 进入:等待唤醒状态(WAITING)");
                    object.wait();
                    System.out.println("thread0 被解除完成:等待唤醒状态(WAITING)");
                }
                System.out.println("thread0 "+Thread.currentThread().getState());
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        // 新创建状态(NEW)
        System.out.println(thread0.getName()+":"+thread0.getState());

        Thread thread1 = new Thread(() -> {
            try {
                System.out.println("thread1 进入:计时等待状态(TIMED_WAITING)");
                Thread.sleep(2);
                System.out.println("thread1 出来:计时等待状态(TIMED_WAITING)");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            // 被阻塞状态(BLOCKED)
            synchronized (object){
                System.out.println("thread1 解除:等待唤醒状态(WAITING)");
                object.notify();
                System.out.println("thread1 解除完成:等待唤醒状态(WAITING)");
            }
            System.out.println("thread1 "+Thread.currentThread().getState());
        });
        // 新创建状态(NEW)
        System.out.println(thread1.getName()+":"+thread1.getState());

        printState(thread0);
        printState(thread1);

        // 可运行状态(RUNNABLE)
        thread0.start();
        // 可运行状态(RUNNABLE)
        thread1.start();

    }
    
    
    // 使用独立线程来打印线程状态
    private static void printState(Thread thread) {
        new Thread(()->{
            while (true){
                System.out.println(thread.getName()+":"+thread.getState());
                if (thread.getState().equals(Thread.State.TERMINATED)){
                    System.out.println(thread.getName()+":"+thread.getState());
                    break;
                }
            }
        }).start();
    }
}

执行结果:简化后的输出结果

Thread-0:NEW
Thread-1:NEW
Thread-0:RUNNABLE
Thread-1:RUNNABLE
thread0 进入:等待唤醒状态(WAITING)
Thread-1:BLOCKED
thread1 进入:计时等待状态(TIMED_WAITING)
Thread-0:BLOCKED
Thread-0:WAITING
……
Thread-0:WAITING
Thread-1:BLOCKED
Thread-1:TIMED_WAITING
……
Thread-1:TIMED_WAITING
Thread-1:BLOCKED
……
Thread-1:BLOCKED
Thread-0:WAITING
……
Thread-0:WAITING
thread1 出来:计时等待状态(TIMED_WAITING)
Thread-0:WAITING
Thread-1:BLOCKED
thread1 解除:等待唤醒状态(WAITING)
Thread-1:BLOCKED
Thread-0:WAITING
Thread-0:BLOCKED
thread1 解除完成:等待唤醒状态(WAITING)
Thread-1:BLOCKED
thread1 RUNNABLE
Thread-0:BLOCKED
Thread-1:TERMINATED
thread0 被解除完成:等待唤醒状态(WAITING)
Thread-0:BLOCKED
thread0 RUNNABLE
Thread-0:TERMINATED

Java线程的6种状态与生命周期

最终的执行结果如图。

注意:因为案例中使用了独立线程来打印不同线程的状态,会出现状态打印稍微延迟的情况。

到此这篇关于一文详解Java线程的6种状态与生命周期的文章就介绍到这了!


Tags in this post...

Java/Android 相关文章推荐
Java Dubbo框架知识点梳理
Jun 26 Java/Android
详解Java线程池是如何重复利用空闲线程的
Jun 26 Java/Android
Java实现多文件上传功能
Jun 30 Java/Android
SpringCloud之@FeignClient()注解的使用方式
Sep 25 Java/Android
Spring Boot项目传参校验的最佳实践指南
Apr 05 Java/Android
SpringBoot中获取profile的方法详解
Apr 08 Java/Android
Java后端 Dubbo retries 超时重试机制的解决方案
Apr 14 Java/Android
Spring Boot 使用 Spring-Retry 进行重试框架
Apr 24 Java/Android
Spring Data JPA框架自定义Repository接口
Apr 28 Java/Android
Android 界面一键变灰 深色主题工具类
Apr 28 Java/Android
Spring Boot 实现 WebSocket
Apr 30 Java/Android
Spring boot admin 服务监控利器详解
Aug 05 Java/Android
Java 多线程协作作业之信号同步
May 11 #Java/Android
Java 数组的使用
May 11 #Java/Android
Java Spring Lifecycle的使用
May 06 #Java/Android
java开发双人五子棋游戏
解决Springboot PostMapping无法获取数据的问题
May 06 #Java/Android
java版 联机五子棋游戏
Java版 简易五子棋小游戏
You might like
调整优化您的LAMP应用程序的5种简单方法
2011/06/26 PHP
php实现在线生成条形码示例分享(条形码生成器)
2013/12/30 PHP
php实现比较两个字符串日期大小的方法
2015/05/12 PHP
PHP通过API获取手机号码归属地
2015/05/28 PHP
Nigma vs Alliance BO5 第三场2.14
2021/03/10 DOTA
Javascript里使用Dom操作Xml
2006/09/20 Javascript
关于jquery动态增减控件的一些想法和小插件
2010/08/01 Javascript
JavaScript对象学习经验整理
2013/10/12 Javascript
JavaScript模拟重力状态下抛物运动的方法
2015/03/03 Javascript
在JavaScript中用getMinutes()方法返回指定的分时刻
2015/06/10 Javascript
浅谈js 闭包引起的内存泄露问题
2015/06/22 Javascript
jquery合并表格中相同文本的相邻单元格
2015/07/17 Javascript
JavaScript继承模式粗探
2016/01/12 Javascript
NodeJS与HTML5相结合实现拖拽多个文件上传到服务器的实现方法
2016/07/26 NodeJs
原生javascript实现的ajax异步封装功能示例
2016/11/03 Javascript
js正则表达式惰性匹配和贪婪匹配用法分析
2016/12/26 Javascript
详解layui弹窗父子窗口之间传参数的方法
2018/01/16 Javascript
微信小程序实现点赞、取消点赞功能
2018/11/02 Javascript
浅析JavaScript 函数柯里化
2020/09/08 Javascript
jQuery实现计算器功能
2020/10/19 jQuery
python类的继承实例详解
2017/03/30 Python
Python 按字典dict的键排序,并取出相应的键值放于list中的实例
2019/02/12 Python
python操作kafka实践的示例代码
2019/06/19 Python
将pycharm配置为matlab或者spyder的用法说明
2020/06/08 Python
关于Python错误重试方法总结
2021/01/03 Python
利用python为PostgreSQL的表自动添加分区
2021/01/18 Python
耐克巴西官方网站:Nike巴西
2016/08/14 全球购物
美国现代家具购物网站:LexMod
2019/01/09 全球购物
奢华时尚的创新平台:Baltini
2020/10/03 全球购物
汉语言文学专业自荐信
2014/06/11 职场文书
幼儿园植树节活动总结
2014/07/04 职场文书
2014年党员个人剖析材料
2014/10/08 职场文书
2014小学教师个人工作总结
2014/11/10 职场文书
2014年纪委工作总结
2014/12/05 职场文书
2016年学校“3.12”植树节活动总结
2016/03/16 职场文书
Python用tkinter实现自定义记事本的方法详解
2022/03/31 Python