Java线程状态转化与Object与Thread对应方法总结

一、线程状态概览

Java 线程的状态由 Thread.State 枚举定义:

  1. 新建(New) :线程对象创建但未调用 start()
  2. 就绪(Runnable):线程已启动,等待 CPU 调度。
  3. 运行(Running) :线程正在执行 run() 方法。
  4. 阻塞(Blocked):线程因等待锁而暂停。
  5. 等待(Waiting):线程等待其他线程的通知,无限期暂停。
  6. 超时等待(Timed Waiting):线程在指定时间内等待。
  7. 终止(Terminated):线程执行完成或异常退出。

线程状态的转换由 JVM 线程调度器和程序员调用的 API 共同控制。下面我们分 ThreadObject 类整理相关方法。


二、Thread 类中的线程相关方法

1. Thread.start()

  • 作用:启动线程,使其从"新建"进入"就绪"状态。

  • 状态转换New -> Runnable

  • 注意 :只能调用一次,重复调用抛出 IllegalThreadStateException

  • 示例

    java 复制代码
    Thread t = new Thread(() -> System.out.println("Thread running"));
    t.start(); // New -> Runnable

2. Thread.sleep(long millis)

  • 作用:使当前线程暂停指定毫秒数,不释放锁。

  • 状态转换Running -> Timed Waiting

  • 示例

    java 复制代码
    Thread.sleep(1000); // 暂停 1 秒,Running -> Timed Waiting

3. Thread.join()

  • 作用:调用线程等待目标线程完成。

  • 状态转换Running -> Waiting(若目标线程未结束)

  • 变体

    • join(long millis):最多等待指定毫秒,Running -> Timed Waiting
  • 示例

    java 复制代码
    Thread t = new Thread(() -> { try { Thread.sleep(2000); } catch (Exception e) {} });
    t.start();
    t.join(); // 主线程等待 t 结束

4. Thread.interrupt()

  • 作用 :中断线程,可能导致 InterruptedException

  • 状态转换 :若线程在 sleepwaitjoin 中,状态可能提前结束。

  • 示例

    java 复制代码
    Thread t = new Thread(() -> {
        try { Thread.sleep(1000); } catch (InterruptedException e) { System.out.println("Interrupted"); }
    });
    t.start();
    t.interrupt();

5. Thread.getState()

  • 作用:查询线程当前状态,不改变状态。

  • 返回值Thread.State 枚举。

  • 示例

    java 复制代码
    Thread t = new Thread(() -> {});
    System.out.println(t.getState()); // NEW
    t.start();
    System.out.println(t.getState()); // RUNNABLE

6. Thread.stop()(已废弃)

  • 作用:强制停止线程。
  • 状态转换 :直接进入 Terminated
  • 注意:不安全,已废弃,不推荐使用。

三、Object 类中的线程相关方法

Object 类的以下方法用于线程间的同步和通信,必须在 synchronized 块中使用。

1. Object.wait()

  • 作用 :使当前线程等待,直到被 notify()notifyAll() 唤醒,释放锁。

  • 状态转换Running -> Waiting

  • 示例

    java 复制代码
    Object lock = new Object();
    synchronized (lock) {
        lock.wait(); // Running -> Waiting
    }

2. Object.wait(long timeout)

  • 作用:等待指定时间,超时后自动唤醒。

  • 状态转换Running -> Timed Waiting

  • 示例

    java 复制代码
    synchronized (lock) {
        lock.wait(1000); // Running -> Timed Waiting
    }

3. Object.notify()

  • 作用:唤醒一个在该对象上等待的线程。

  • 状态转换Waiting -> Runnable

  • 示例

    java 复制代码
    synchronized (lock) {
        lock.notify(); // 唤醒一个等待线程
    }

4. Object.notifyAll()

  • 作用:唤醒所有在该对象上等待的线程。

  • 状态转换Waiting -> Runnable(所有等待线程)

  • 示例

    java 复制代码
    synchronized (lock) {
        lock.notifyAll(); // 唤醒所有等待线程
    }

四、线程状态转换全景

以下是线程状态的完整转换路径及触发条件:

  1. New -> Runnable

    • 方法:Thread.start()
    • 描述:线程启动,进入就绪队列。
  2. Runnable -> Running

    • 方法:无(JVM 调度器控制)
    • 描述:线程被调度,获得 CPU 时间。
  3. Running -> Timed Waiting

    • 方法:Thread.sleep()Object.wait(timeout)Thread.join(timeout)
    • 描述:线程暂停一段时间。
  4. Running -> Waiting

    • 方法:Object.wait()Thread.join()
    • 描述:线程无限期等待其他线程通知。
  5. Running -> Blocked

    • 方法:无(锁竞争)
    • 描述:线程尝试获取已被占用的锁。
  6. Waiting/Timed Waiting -> Runnable

    • 方法:Object.notify()Object.notifyAll()、超时结束
    • 描述:线程被唤醒或超时,返回就绪状态。
  7. Blocked -> Runnable

    • 方法:无(锁释放)
    • 描述:其他线程释放锁。
  8. Running -> Terminated

    • 方法:自然结束、Thread.interrupt()
    • 描述:线程执行完成或被中断。

五、综合示例

以下代码展示线程状态的常见转换:

java 复制代码
public class ThreadStateDemo {
    public static void main(String[] args) throws InterruptedException {
        Object lock = new Object();
        Thread t1 = new Thread(() -> {
            synchronized (lock) {
                try {
                    System.out.println("t1: Running");
                    lock.wait(); // Running -> Waiting
                    System.out.println("t1: Resumed");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        System.out.println("t1 state: " + t1.getState()); // NEW
        t1.start();
        Thread.sleep(100); // 确保 t1 进入 wait
        System.out.println("t1 state: " + t1.getState()); // WAITING

        synchronized (lock) {
            lock.notify(); // Waiting -> Runnable
        }
        t1.join(); // 主线程等待 t1 结束
        System.out.println("t1 state: " + t1.getState()); // TERMINATED
    }
}

输出

yaml 复制代码
t1 state: NEW
t1: Running
t1 state: WAITING
t1: Resumed
t1 state: TERMINATED

六、总结

  • Thread 提供了线程的启动 (start)、暂停 (sleep)、等待 (join) 和中断 (interrupt) 等功能。
  • Object 提供了线程间通信的机制 (waitnotifynotifyAll),依赖同步锁。
  • 线程状态转换既有程序员显式控制的部分(如 startwait),也有 JVM 自动管理的部分(如 Runnable -> Running)。

掌握这些方法和状态转换,能帮助开发者更好地设计和管理多线程程序。希望这篇博客对你理解 Java 线程有所帮助!

相关推荐
雷渊3 分钟前
微服务中为什么要设计不同的服务和不同的数据对象,体现了一个什么样的设计思想?
后端
无奈何杨32 分钟前
CoolGuard风控中新增移动距离和移动速度指标
前端·后端
程序员爱钓鱼1 小时前
Go语言泛型-泛型约束与实践
前端·后端·go
寻月隐君1 小时前
保姆级教程:Zsh + Oh My Zsh 终极配置,让你的 Ubuntu 终端效率倍增
linux·后端·命令行
程序员爱钓鱼1 小时前
Go语言泛型-泛型对代码结构的优化
后端·google·go
这里有鱼汤1 小时前
“对象”?对象你个头!——Python世界观彻底崩塌的一天
后端·python
RainbowSea1 小时前
跨域问题(Allow CORS)解决(3 种方法)
java·spring boot·后端
sniper_fandc3 小时前
SpringBoot系列—入门
java·spring boot·后端
Piper蛋窝9 小时前
深入 Go 语言垃圾回收:从原理到内建类型 Slice、Map 的陷阱以及为何需要 strings.Builder
后端·go
六毛的毛12 小时前
Springboot开发常见注解一览
java·spring boot·后端