脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Java线程

Java线程生命周期及转换过程

 更新时间：2022年05月09日 13:59:56   作者：​ Java中文社群   ​  
这篇文章主要介绍了Java线程生命周期及转换过程，线程的生命周期指的是线程从创建到销毁的整个过程初始状态、可运行状态、运行状态、休眠状态、终止状态，更多详细介绍，需要的小伙伴可以参考下面文章内容

前言：

线程的生命周期指的是线程从创建到销毁的整个过程，通常情况下线程的生命周期有以下 5 种：

  • 初始状态
  • 可运行状态
  • 运行状态
  • 休眠状态
  • 终止状态

它们的状态转换如下图所示： 

Java 线程生命周期

Java 线程的生命周期和上面说的生命周期是不同的，它有以下 6 种状态：

  • NEW（初始化状态）
  • RUNNABLE（可运行/运行状态）
  • BLOCKED（阻塞状态）
  • WAITING（无时限等待状态）
  • TIMED_WAITING（有时限等待状态）
  • TERMINATED（终止状态）

我们可以在 Thread 的源码中可以找到这 6 种状态，如下所示： 

 当然你也可以使用 Java 代码，来打印所有的线程状态，如下代码所示：

for (Thread.State value : Thread.State.values()) {
    System.out.println(value);
}

以上程序的执行结果如下图所示： 

生命周期转换

接下来我们聊聊 Java 线程生命周期的转换过程。

1.从 NEW 到 RUNNABLE

当我们创建一个线程的时候，也就是 new Thread 的时候，此时线程是 NEW 状态，如下代码所示：

// 创建线程
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        // ...
    }
});
// 获取线程状态
Thread.State state = thread.getState();
System.out.println(state);

以上程序的执行结果如下图所示： 

 然而调用了线程的 start 方法之后，线程的状态就从 NEW 变成了 RUNNABLE，

如下代码所示：

// 创建线程
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        // 获取到当前执行的线程
        Thread currThread = Thread.currentThread();
        // 获取线程状态
        Thread.State state = currThread.getState();
        // 打印线程状态
        System.out.println(state);
    }
});
thread.start();

以上程序的执行结果如下图所示： 

2.从 RUNNABLE 到 BLOCKED

当线程中的代码排队执行 synchronized 时，线程就会从 RUNNABLE 状态变为 BLOCKED 阻塞状态

如下代码所示：

// 创建线程
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            // 等待 100 毫秒
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("排队使用锁");
        synchronized (ThreadStates.class) {
        }
    }
});
thread.start();
// 让主线程先得到锁
synchronized (ThreadStates.class) {
    // 获取线程状态
    Thread.State state = thread.getState();
    // 打印线程状态
    System.out.println("首次获取线程状态：" + state);
    // 休眠 1s
    try {
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    // 再次获取线程状态
    state = thread.getState();
    // 打印线程状态
    System.out.println("第二次获取线程状态：" + state);
}

以上程序的执行结果如下图所示： 

 当线程获取到 synchronized 锁之后，就会从 BLOCKED 状态转变为 RUNNABLE 状态。

3.从 RUNNABLE 到 WAITTING

线程调用 wait() 方法之后，就会从 RUNNABLE 状态变为 WAITING 无时限等待状态，如下所示：

// 创建线程
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        synchronized (this) {
            try {
                // 线程休眠
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
});
// 启动线程
thread.start();
// 获取线程状态
Thread.State state = thread.getState();
// 打印线程状态
System.out.println("首次获取线程状态：" + state);
// 休眠 1s
try {
    Thread.sleep(1000);
} catch (InterruptedException e) {
    e.printStackTrace();
}
// 获取线程状态
state = thread.getState();
// 打印线程状态
System.out.println("第二次获取线程状态：" + state);

以上程序的执行结果如下图所示： 

 当调用了 notify/notifyAll 方法之后，线程会从 WAITING 状态变成 RUNNABLE 状态，

如下代码所示：

Object lock = new Object();
// 创建线程
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        synchronized (lock) {
            try {
                // 线程休眠
                lock.wait();
                // 获取当前线程状态
                Thread.State state = Thread.currentThread().getState();
                // 打印线程状态
                System.out.println("获取线程状态：" + state);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
});
// 启动线程
thread.start();
// 获取线程状态
Thread.State state = thread.getState();
// 打印线程状态
System.out.println("首次获取线程状态：" + state);
// 休眠 1s
try {
    Thread.sleep(100);
} catch (InterruptedException e) {
    e.printStackTrace();
}
// 获取线程状态
state = thread.getState();
// 打印线程状态
System.out.println("第二次获取线程状态：" + state);

// 唤醒 thread 线程
synchronized (lock) {
    lock.notify();
}

以上程序的执行结果如下图所示： 

4.从 RUNNABLE 到 TIMED_WATTING

当调用带超时时间的等待方法时，如 sleep(xxx)，线程会从 RUNNABLE 状态变成 TIMED_WAITING 有时限状态，

如下代码所示：

// 创建线程
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});
// 启动线程
thread.start();
// 获取线程状态
Thread.State state = thread.getState();
// 打印线程状态
System.out.println("首次获取线程状态：" + state);
// 休眠 1s
try {
    Thread.sleep(100);
} catch (InterruptedException e) {
    e.printStackTrace();
}
// 获取线程状态
state = thread.getState();
// 打印线程状态
System.out.println("第二次获取线程状态：" + state);

以上程序的执行结果如下图所示： 

 当超过了超时时间之后，线程就会从 TIMED_WAITING 状态变成 RUNNABLE 状态，

实现代码如下：

// 创建线程
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        try {
            Thread.sleep(1000);
            // 获取当前线程状态
            Thread.State state = Thread.currentThread().getState();
            // 打印线程状态
            System.out.println("获取线程状态：" + state);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
});
// 启动线程
thread.start();
// 获取线程状态
Thread.State state = thread.getState();
// 打印线程状态
System.out.println("首次获取线程状态：" + state);
// 休眠 1s
try {
    Thread.sleep(100);
} catch (InterruptedException e) {
    e.printStackTrace();
}
// 获取线程状态
state = thread.getState();
// 打印线程状态
System.out.println("第二次获取线程状态：" + state);

以上程序的执行结果如下图所示： 

5.RUNNABLE 到 TERMINATED

线程执行完之后，就会从 RUNNABLE 状态变成 TERMINATED 销毁状态，如下代码所示：

// 创建线程
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        // 获取当前线程状态
        Thread.State state = Thread.currentThread().getState();
        // 打印线程状态
        System.out.println("获取线程状态：" + state);
    }
});
// 启动线程
thread.start();
// 等待 100ms，待线程执行完
Thread.sleep(100);
// 获取线程状态
Thread.State state = thread.getState();
// 打印线程状态
System.out.println("线程状态：" + state);

以上程序的执行结果如下图所示： 

总结

Java 中线程的生命周期有 6 种：NEW（初始化状态）、RUNNABLE（可运行/运行状态）、BLOCKED（阻塞状态）、WAITING（无时限等待状态）、TIMED_WAITING（有时限等待状态）、TERMINATED（终止状态）。

线程生命周期的转换流程如下图所示： 

到此这篇关于Java线程生命周期及转换过程的文章就介绍到这了,更多相关Java线程内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

相关文章

  • Mybatis中输入输出映射与动态Sql图文详解

    Mybatis中输入输出映射与动态Sql图文详解

    这篇文章主要给大家介绍了关于Mybatis中输入输出映射与动态Sql的相关资料,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
    2019-02-02
  • RestTemplate报错400 Bad Request的解决方案

    RestTemplate报错400 Bad Request的解决方案

    在使用Spring Boot时,若直接通过@Autowired注入RestTemplate可能会遇到400BadRequest错误,原因在于Spring Boot官方文档指出,由于RestTemplate实例通常需要在使用前进行定制,因此Spring Boot不会自动配置单个RestTemplate Bean
    2024-11-11
  • Linux下Java开发环境搭建以及第一个HelloWorld

    Linux下Java开发环境搭建以及第一个HelloWorld

    这篇文章主要介绍了Linux下Java开发环境搭建以及第一个HelloWorld的实现过程，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
    2015-09-09
  • Log4j定时打印日志及添加模块名配置的Java代码实例

    Log4j定时打印日志及添加模块名配置的Java代码实例

    这篇文章主要介绍了Log4j定时打印日志及添加模块名配置的Java代码实例,Log4j是Apache的一个开源Java日志项目,需要的朋友可以参考下
    2016-01-01
  • Java实现差分数组的示例详解

    Java实现差分数组的示例详解

    差分数组是由原数组进化而来，值为原数组当前位置值减去上一个位置的值。本文将通过例题详解如何利用Java实现差分数组，需要的可以参考一下
    2022-06-06
  • Java annotation元注解原理实例解析

    Java annotation元注解原理实例解析

    这篇文章主要介绍了Java annotation元注解原理实例解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
    2020-03-03
  • 如何关闭 IDEA 自动更新

    如何关闭 IDEA 自动更新

    这篇文章主要介绍了如何关闭 IDEA 自动更新,本文通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有一定的参考借鉴价值，需要的朋友可以参考下
    2020-12-12
  • java获取手机已安装APK的签名摘要

    java获取手机已安装APK的签名摘要

    这篇文章主要介绍了java获取手机已安装APK的签名摘要的相关资料,需要的朋友可以参考下
    2016-02-02
  • 浅谈Java中父类与子类的加载顺序详解

    浅谈Java中父类与子类的加载顺序详解

    本篇文章是对Java中父类与子类的加载顺序进行了详细的分析介绍，需要的朋友参考下
    2013-06-06
  • Spring中的@Transactional事务失效场景解读

    Spring中的@Transactional事务失效场景解读

    这篇文章主要介绍了Spring中的@Transactional事务失效场景解读,如果Transactional注解应用在非public 修饰的方法上,Transactional将会失效此方法会检查目标方法的修饰符是否为 public,不是 public则不会获取@Transactional 的属性配置信息,需要的朋友可以参考下
    2023-12-12

最新评论