Java线程解析：三态和五态

在这里插入图片描述

博主 默语带您 Go to New World.
✍ 个人主页—— 默语 的博客👦🏻
《java 面试题大全》
🍩惟余辈才疏学浅，临摹之作或有不妥之处，还请读者海涵指正。☕🍭
《MYSQL从入门到精通》数据库是开发者必会基础之一~
🪁 吾期望此文有资助于尔，即使粗浅难及深广，亦备添少许微薄之助。苟未尽善尽美，敬请批评指正，以资改进。！💻⌨

《Java线程状态深度解析：三态和五态探秘 😎》

摘要

嘿，各位Java小伙伴们，博主又来啦！今天我们要揭开Java线程状态的神秘面纱，深入研究线程的三态和五态，了解线程在不同状态之间的转变过程。通过详细的代码演示和深入的探讨，让我们一起探秘线程状态的奥秘，助你在多线程编程中游刃有余！ 🚀

引言

在Java编程中，理解线程状态是高效编写多线程程序的关键。本文将深入研究线程的三态（新建、运行、阻塞）和五态（新建、运行、阻塞、等待、计时等待）之间的关系，通过大量代码案例演示，为你呈现线程状态的全貌。

一、什么是三态 😊

三态指的是线程的三种基本状态：新建、运行和阻塞。在多线程编程中，了解线程的三态非常重要，因为它们描述了线程在不同阶段的行为和状态转换。

  1. 新建状态（New）：

    • 当使用 new 关键字创建一个线程对象时，该线程处于新建状态。
    • 新建状态的线程还没有开始执行，处于等待状态，直到调用 start() 方法启动线程。

    在新建状态下，线程已经被创建，但尚未启动执行任何代码。线程对象的相关资源已被分配，但是操作系统还没有为其分配 CPU 时间片。要使线程开始执行，必须调用 start() 方法，这会将线程转移到可运行状态（Runnable）。

 public class NewThreadDemo extends Thread {
       public void run() {
           System.out.println("新线程执行");
       }
   public static void main(String[] args) {
       // 创建新线程对象
       NewThreadDemo thread = new NewThreadDemo();
       // 此时线程处于新建状态，尚未启动
   
       // 调用 start() 方法启动线程，将线程转移到可运行状态（Runnable）
       thread.start();
   }
   }

  1. 运行状态（Runnable）：

    • 线程调用 start() 方法后，进入运行状态。
    • 在运行状态中，线程正在执行任务或等待执行。
    • 处于运行状态的线程可能会因为时间片用完、主动调用 sleep()、yield() 或 wait() 方法，或者被其他线程抢占 CPU 而进入阻塞状态。

    在运行状态下，线程已经开始执行任务或者等待执行。它可能在执行过程中主动放弃 CPU 时间片，让其他线程执行（yield() 方法），也可能主动暂停一段时间（sleep() 方法），或者等待某个条件的满足（wait() 方法）。当线程执行完毕、被阻塞、或者时间片用完时，线程将会离开运行状态。

    public class RunnableThreadDemo {
    public static void main(String[] args) {
        // 创建一个线程对象，并传入一个任务
        Thread thread = new Thread(() -> {
            // 线程执行任务
            for (int i = 1; i <= 5; i++) {
                System.out.println("线程正在执行：" + i);
                try {
                    // 模拟线程执行过程中的一些操作
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        // 调用 start() 方法启动线程，线程进入运行状态
        thread.start();
    }
}

  2. 阻塞状态（Blocked）：

    • 线程处于阻塞状态时，不能继续执行，暂时停止运行，直到某种条件得到满足。
    • 线程进入阻塞状态的原因可能包括等待输入/输出、获取锁失败、调用 sleep()、yield()、wait() 方法等。
    • 当阻塞状态的线程满足条件后，它会重新进入就绪状态，等待 CPU 调度执行。

    在阻塞状态下，线程暂时停止运行，等待某种条件的满足。这种条件可能是等待输入/输出完成、获取锁失败、或者主动调用了一些暂停线程执行的方法（如 sleep()、yield()、wait()）。当线程满足条件后，它会重新进入就绪状态，等待操作系统重新分配 CPU 资源，并且再次开始执行。

   public class BlockedThreadDemo {
       public static void main(String[] args) {
           final Object lock = new Object();
   
           Thread taskThread = new Thread(() -> {
               synchronized (lock) {
                   System.out.println("任务线程获取了锁并开始执行任务...");
                   // 模拟执行耗时任务
                   try {
                       Thread.sleep(5000); // 任务线程休眠5秒钟
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   System.out.println("任务线程执行完毕，释放了锁。");
               }
           });
   
           Thread waitingThread = new Thread(() -> {
               synchronized (lock) {
                   System.out.println("获取锁成功！但不会执行到这里，因为任务线程持有锁...");
               }
           });
   
           taskThread.start(); // 启动任务线程
   
           // 等待一段时间后再尝试获取锁
           try {
               Thread.sleep(1000); // 等待1秒钟
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
   
           waitingThread.start(); // 尝试获取锁的线程开始执行
   
           // 等待尝试获取锁的线程执行完毕
           try {
               waitingThread.join();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
   }

线程的状态转换如下：

  • 从新建状态到运行状态：调用 start() 方法启动线程。
  • 从运行状态到阻塞状态：线程等待某些条件的满足。
  • 从阻塞状态到运行状态：条件满足后，线程重新进入就绪状态，等待 CPU 调度执行。

通过了解线程的三态及其状态转换，我们可以更好地理解线程在不同情况下的行为，从而更有效地进行多线程编程。

二、什么是五态 😃

五态则包括了三态的基础上，增加了等待和计时等待状态。通过深入研究，我们将揭示线程在这五个状态之间如何灵活切换，为你呈现线程状态的更加细致的画面。

五态是指线程的五种基本状态，包括新建、运行、阻塞、等待和计时等待状态。在多线程编程中，了解线程的五态是非常重要的，因为它们描述了线程在不同阶段的行为和状态转换。

    • 新建状态（New）：

      • 当使用 new 关键字创建一个线程对象时，该线程处于新建状态。
      • 新建状态的线程还没有开始执行，处于等待状态，直到调用 start() 方法启动线程。

      在新建状态下，线程已经被创建，但尚未启动执行任何代码。线程对象的相关资源已被分配，但是操作系统还没有为其分配 CPU 时间片。要使线程开始执行，必须调用 start() 方法，这会将线程转移到可运行状态（Runnable）。

  2. 运行状态（Runnable）：

    • 线程调用 start() 方法后，进入运行状态。
    • 在运行状态中，线程正在执行任务或等待执行。

  3. 阻塞状态（Blocked）：

    • 线程处于阻塞状态时，不能继续执行，暂时停止运行，直到某种条件得到满足。

  4. 等待状态（Waiting）：

    • 线程在等待某个条件的满足时进入等待状态，与阻塞状态不同的是，等待状态下的线程不会被调度执行。
    • 线程可以通过 Object.wait()、Thread.join()、LockSupport.park() 等方法进入等待状态。

  5. 计时等待状态（Timed Waiting）：

    • 计时等待状态是等待状态的一个特例，线程在等待某个条件的满足时可以设置一个超时时间，在超时时间内未满足条件则线程自动唤醒。
    • 线程可以通过 Thread.sleep()、Object.wait(long timeout)、Thread.join(long millis)、LockSupport.parkNanos()、LockSupport.parkUntil() 等方法进入计时等待状态。

这五种状态描述了线程在不同阶段的行为和状态转换，了解和掌握线程的五态对于进行多线程编程非常重要。

三、五态之间如何转变

3.1 新建状态转换到运行状态

在新建状态下的线程如何转变为运行状态？我们将通过代码案例演示这一过程，助你更好地理解线程状态的变化。

public class NewToRunnableDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            // 线程任务代码
            System.out.println("线程开始执行任务...");
        });

        // 此时线程对象已经创建，处于新建状态
        System.out.println("线程处于新建状态");

        // 调用 start() 方法，将线程对象转变为运行状态
        thread.start();

        // 线程启动后，处于运行状态
        System.out.println("线程处于运行状态");
    }
}

在这个示例中，我们创建了一个线程对象 thread，但此时线程对象处于新建状态。然后，我们调用 start() 方法启动线程，这会将线程对象转变为运行状态。一旦线程处于运行状态，它就有机会被操作系统调度并开始执行任务。

3.2 运行状态转换到阻塞状态

当线程运行时，如果遇到阻塞条件，会如何转变为阻塞状态？我们将详细探讨阻塞状态的产生及其解决方案。

public class RunnableToBlockedDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("线程开始执行任务...");

            // 模拟阻塞条件：线程休眠一段时间
            try {
                Thread.sleep(2000); // 线程休眠2秒钟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 执行完阻塞操作后，线程继续执行任务
            System.out.println("线程继续执行任务...");
        });

        // 启动线程
        thread.start();

        // 主线程等待一段时间，然后检查线程状态
        try {
            Thread.sleep(1000); // 主线程休眠1秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 检查线程状态
        Thread.State state = thread.getState();
        System.out.println("线程当前状态：" + state);
    }
}

在这个示例中，我们创建了一个线程对象 thread，并启动了线程。线程开始执行任务，并在任务中模拟了一个阻塞条件：线程休眠2秒钟。在线程休眠期间，线程处于阻塞状态。主线程等待1秒钟后，通过检查线程状态来观察线程是否处于阻塞状态。

3.3 运行状态转换到等待状态

线程在运行时，如何转变为等待状态？通过实例演示，我们将揭晓等待状态的应用场景和解决方法。

public class RunnableToWaitingDemo {
    public static void main(String[] args) {
        Object lock = new Object();

        Thread thread = new Thread(() -> {
            synchronized (lock) {
                System.out.println("线程开始执行任务...");

                // 模拟等待条件：线程调用 wait() 方法进入等待状态
                try {
                    lock.wait(); // 线程等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

                // 等待状态结束后，线程继续执行任务
                System.out.println("线程继续执行任务...");
            }
        });

        // 启动线程
        thread.start();

        // 主线程等待一段时间，然后检查线程状态
        try {
            Thread.sleep(1000); // 主线程休眠1秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 检查线程状态
        Thread.State state = thread.getState();
        System.out.println("线程当前状态：" + state);
    }
}

在这个示例中，我们创建了一个线程对象 thread，并启动了线程。线程开始执行任务，并在任务中模拟了一个等待条件：线程调用 wait() 方法进入等待状态。在等待状态期间，线程会等待其他线程通过 notify() 或 notifyAll() 方法来唤醒它。主线程等待1秒钟后，通过检查线程状态来观察线程是否处于等待状态。

3.4 运行状态转换到计时等待状态

计时等待状态是如何产生的？我们将通过具体案例，深入剖析计时等待状态的特点和使用方法。

public class RunnableToTimedWaitingDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("线程开始执行任务...");

            // 模拟计时等待条件：线程调用 sleep() 方法进入计时等待状态
            try {
                Thread.sleep(3000); // 线程休眠3秒钟
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            // 计时等待状态结束后，线程继续执行任务
            System.out.println("线程继续执行任务...");
        });

        // 启动线程
        thread.start();

        // 主线程等待一段时间，然后检查线程状态
        try {
            Thread.sleep(1000); // 主线程休眠1秒钟
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 检查线程状态
        Thread.State state = thread.getState();
        System.out.println("线程当前状态：" + state);
    }
}

在这个示例中，我们创建了一个线程对象 thread，并启动了线程。线程开始执行任务，并在任务中模拟了一个计时等待条件：线程调用 sleep() 方法进入计时等待状态，即线程会休眠3秒钟。在计时等待状态期间，线程不会执行任何操作，只是等待指定的时间。主线程等待1秒钟后，通过检查线程状态来观察线程是否处于计时等待状态。

3.5 运行状态转换到终止状态

线程运行结束后，如何转变为终止状态？我们将通过实际代码示例，为你展示线程如何优雅地结束生命周期。

public class RunnableToTerminatedDemo {
    public static void main(String[] args) {
        Thread thread = new Thread(() -> {
            System.out.println("线程开始执行任务...");
            // 模拟线程执行任务
            for (int i = 0; i < 5; i++) {
                System.out.println("线程执行中：" + i);
                try {
                    Thread.sleep(1000); // 线程休眠1秒钟
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程任务执行完毕。");
        });

        // 启动线程
        thread.start();

        // 等待线程执行完毕
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 检查线程状态
        Thread.State state = thread.getState();
        System.out.println("线程当前状态：" + state);
    }
}

在这个示例中，我们创建了一个线程对象 thread，并启动了线程。线程开始执行任务，执行完任务后线程即将进入终止状态。主线程调用 join() 方法等待线程执行完毕，然后通过检查线程状态来观察线程是否处于终止

四、五态的应用场景 🌐

除了了解状态转换的过程，我们还将深入研究线程状态在实际项目中的应用场景。通过大量实例，助你更好地理解线程状态在不同场景下的灵活应用。

1. 新建状态（New）：

  • 在多线程编程中，新建状态通常出现在创建线程对象后，但尚未调用 start() 方法启动线程的阶段。这种状态常见于线程池中的空闲线程对象。

2. 运行状态（Runnable）：

  • 运行状态是线程正在执行任务或等待执行的状态。这种状态在任何需要执行的线程中都会出现，例如，处理客户请求的服务器线程、执行计算任务的后台线程等。

3. 阻塞状态（Blocked）：

  • 阻塞状态是指线程因为某些条件无法继续执行而暂时停止运行的状态。在并发编程中，常见的阻塞情况包括等待锁资源、等待输入/输出完成等。

4. 等待状态（Waiting）：

  • 等待状态是指线程在等待其他线程的通知或条件满足时暂时停止执行的状态。例如，线程调用 wait() 方法进入等待状态，直到其他线程调用 notify() 或 notifyAll() 方法来唤醒它。

5. 计时等待状态（Timed Waiting）：

  • 计时等待状态是等待状态的一个特例，线程在等待某个条件的满足时可以设置一个超时时间，在超时时间内未满足条件则线程自动唤醒。这种状态常见于等待超时的场景，例如网络连接超时、任务执行超时等。

通过深入理解线程的五态及其在实际项目中的应用场景，我们可以更好地利用多线程编程来解决各种复杂的并发问题，提高程序的性能和可靠性。

五、JAVA五态面试题 ❓

在面试中，对线程状态的深入理解将为你赢得宝贵分数。本节将提供一些常见的线程状态面试题，帮助你在面试时从容应对，展现你在多线程编程领域的专业知识。

线程的五态指的是线程在操作系统中的五种状态，通常是新建、就绪、运行、阻塞和终止。在Java中，这些状态可以稍微不同，但是概念基本相同。

  1. 新建状态（New）：当线程对象被创建时，它处于新建状态。在这个状态下，操作系统为线程分配了资源，但尚未执行线程的run()方法。

  2. 就绪状态（Runnable）：线程处于就绪状态时，表示线程已经准备好运行，但尚未获得 CPU 时间片。当线程处于就绪状态时，它等待操作系统分配 CPU 资源。

  3. 运行状态（Running）：线程处于运行状态时，表示它正在执行其run()方法中的代码，并且正在使用 CPU 执行指令。

  4. 阻塞状态（Blocked）：线程处于阻塞状态时，表示线程暂时无法执行。这可能是由于等待输入/输出、等待获取锁、等待其他线程的通知等原因造成的。线程在此状态下会暂时释放CPU资源。

  5. 终止状态（Terminated）：线程处于终止状态时，表示线程执行完了run()方法中的所有代码，或者因为异常等原因提前结束了。在这个状态下，线程将被销毁，释放所有的资源。

线程如何从新建状态转变为运行状态？

  • 线程从新建状态转变为运行状态通常是通过调用start()方法来启动线程。这会导致线程进入就绪状态，然后根据CPU调度器的调度，进入运行状态。

线程如何从运行状态转变为阻塞状态？

  • 线程从运行状态转变为阻塞状态通常是由于某些阻塞操作，例如等待输入/输出或等待获取锁。一旦线程执行了这些操作，它将进入阻塞状态，等待条件满足或锁释放。

线程如何从运行状态转变为等待状态？

  • 线程从运行状态转变为等待状态通常是通过调用wait()方法来等待某些条件的发生。在这种情况下，线程会释放它所持有的锁，并进入等待状态，直到其他线程唤醒它。

线程如何从运行状态转变为计时等待状态？

  • 线程从运行状态转变为计时等待状态通常是通过调用sleep()方法或者指定等待时间的wait()方法。线程在这种状态下会暂停执行一段时间，然后根据指定的时间重新进入就绪状态。

线程如何从运行状态转变为终止状态？

  • 线程从运行状态转变为终止状态通常是因为线程执行完了其run()方法中的所有代码，或者因为发生了未捕获的异常导致线程提前结束。在这种情况下，线程将进入终止状态并释放所有资源。

在Java中，线程如何被唤醒？

  • 在Java中，线程可以通过调用notify()、notifyAll()或者interrupt()方法来唤醒。这些方法可以在等待状态下的线程被其他线程唤醒，使其重新进入就绪状态。

在Java中，如何检查线程的状态？

  • 在Java中，可以通过Thread类的getState()方法来检查线程的状态。该方法返回一个枚举值，表示线程的当前状态。

线程的状态转换是同步的还是异步的？为什么？

  • 线程的状态转换通常是异步的，因为线程的状态转换受到操作系统和CPU调度器的管理。线程的状态转换不受程序控制，而是由操作系统和CPU调度器决定。因此，线程的状态转换是异步的。

在Java中，如何避免线程死锁？

  • 要避免线程死锁，可以采取以下措施：
    1. 避免嵌套锁，即在持有一个锁的情况下再去申请另一个锁。
    2. 使用线程安全的并发工具，如ConcurrentHashMap、CopyOnWriteArrayList等，它们内部实现了避免死锁的机制。
    3. 使用try-with-resources或手动释放锁，确保在使用锁的过程中，锁能够被正确释放，不会因为异常而造成死锁。
    4. 使用同步代码块时，确保锁的获取顺序是一致的，避免不同线程获取锁的顺序不一致导致死锁的发生。

六、总结 🎉

通过本文的学习，相信你已经对Java线程的三态和五态有了更深入的认识。从基础概念到实际应用，我们一起揭示了线程状态的方方面面。让我们在总结中回顾一下重要的知识点，为未来的多线程编程之旅画上精彩的句号。

参考资料

在编写本文时，我参考了许多优秀的教材和在线文档。如果你对Java线程状态还有更多的疑问或想深入学习，可以查阅以下参考资料：

希望这篇博客能够为你在Java线程状态的学习之路上提供充足的帮助。如果有任何问题或建议，欢迎留言讨论，我们一起进步！ 🌟

在这里插入图片描述

🪁🍁 希望本文能够给您带来一定的帮助🌸文章粗浅，敬请批评指正！🍁🐥

如对本文内容有任何疑问、建议或意见，请联系作者，作者将尽力回复并改进📓；(联系微信:Solitudemind )

点击下方名片，加入IT技术核心学习团队。一起探索科技的未来，共同成长。

在这里插入图片描述

# java # 开发语言
Logo
科技创新，汇聚千年文化底蕴，共筑璀璨首都未来之梦！

欢迎加入北京社区

更多推荐

cover

️ 解决AI推理中的“Segmentation Fault”错误：内存访问调试

avatar 北京城市开发者社区
cover

修复AI训练中的“Learning Rate Too High”错误：参数调整策略 ️

avatar 北京城市开发者社区
cover

修复AI训练中的“Optimizer Not Converging”错误：优化器调整方法

avatar 北京城市开发者社区