寒假打卡02_1月14日

Java 线程的生命周期与状态

在多线程编程中,理解线程的生命周期和状态是非常重要的。Java 线程的生命周期可以分为多个阶段,每个阶段都有不同的状态。在本篇文章中,我们将详细探讨 Java 线程的生命周期和各个状态。

线程的生命周期

Java 线程的生命周期大致可以分为以下几个阶段:

  1. 新建(New)
  2. 就绪(Runnable)
  3. 运行(Running)
  4. 阻塞(Blocked)
  5. 等待(Waiting)
  6. 计时等待(Timed Waiting)
  7. 终止(Terminated)

1. 新建(New)

当一个线程对象被创建时,它处于新建状态。这时,线程还没有开始执行。

Thread thread = new Thread(() -> {
    // 线程执行的代码
});

2. 就绪(Runnable)

当调用线程的 start() 方法后,线程进入就绪状态。就绪状态的线程已经准备好等待 CPU 的调度。

thread.start();

3. 运行(Running)

当线程获取到 CPU 资源后,它进入运行状态,开始执行线程的 run() 方法中的代码。

@Override
public void run() {
    // 运行中的线程代码
}

4. 阻塞(Blocked)

线程在等待获取监视器锁时进入阻塞状态。当线程试图进入同步代码块或方法,但目标锁已经被其他线程持有时,它会进入阻塞状态。

synchronized (lock) {
    // 同步代码块
}

5. 等待(Waiting)

当线程等待另一个线程显式地唤醒它时,它进入等待状态。调用 Object.wait()Thread.join()LockSupport.park() 方法时,线程会进入等待状态。

synchronized (lock) {
    lock.wait();
}

6. 计时等待(Timed Waiting)

线程在指定时间内等待另一线程的动作。调用 Thread.sleep(long millis)Object.wait(long timeout)Thread.join(long millis) 方法时,线程会进入计时等待状态。

Thread.sleep(1000);

7. 终止(Terminated)

当线程的 run() 方法执行完毕或抛出未捕获的异常时,线程进入终止状态。

@Override
public void run() {
    // 线程执行完毕
}

线程状态转换图

以下是 Java 线程状态的转换图:

New -> Runnable -> Running -> Terminated
        ^      |       |
        |      |       v
        |      +-----> Blocked
        |              |
        |              v
        +-----------> Waiting
                       |
                       v
                   Timed Waiting

示例代码

以下是一个示例代码,展示了线程从新建状态到终止状态的转换过程:

public class ThreadLifecycleDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            try {
                System.out.println("Thread is running");
                Thread.sleep(1000); // Timed Waiting
                synchronized (ThreadLifecycleDemo.class) {
                    ThreadLifecycleDemo.class.wait(); // Waiting
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        System.out.println("Thread state after creation: " + thread.getState()); // New
        thread.start();
        System.out.println("Thread state after start: " + thread.getState()); // Runnable

        try {
            Thread.sleep(500); // Main thread sleep to let the new thread run
            System.out.println("Thread state while running: " + thread.getState()); // Running
            synchronized (ThreadLifecycleDemo.class) {
                ThreadLifecycleDemo.class.notify();
            }
            Thread.sleep(500); // Main thread sleep to let the new thread finish
            System.out.println("Thread state after completion: " + thread.getState()); // Terminated
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

总结

Java 线程的生命周期包括多个状态,从新建到终止,中间可能经历就绪、运行、阻塞、等待和计时等待等状态。理解这些状态及其转换对于编写高效且健壮的多线程程序至关重要。

希望通过本篇文章,大家对 Java 线程的生命周期和状态有了更深入的了解。在接下来的文章中,我们将继续探讨更多关于 Java 多线程的知识点,敬请期待!

posted @   aallofitisst  阅读(2)  评论(0编辑  收藏  举报
相关博文:
阅读排行:
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· 没有源码,如何修改代码逻辑?
· PowerShell开发游戏 · 打蜜蜂
· 在鹅厂做java开发是什么体验
· WPF到Web的无缝过渡:英雄联盟客户端的OpenSilver迁移实战
点击右上角即可分享
微信分享提示