【昕宝爸爸小模块】线程的几种状态，状态之间怎样流转

程序员安然2024-01-15 1:00

➡️博客首页 https://blog.csdn.net/Java_Yangxiaoyuan

欢迎优秀的你👍点赞、🗂️收藏、加❤️关注哦。

本文章CSDN首发，欢迎转载，要注明出处哦！

先感谢优秀的你能认真的看完本文，有问题欢迎评论区交流，都会认真回复！

线程的几种状态，状态之间怎样流转

  • 一、✅典型解析
    • [1.1 ✅线程的优先级对程序的性能有什么影响](#1.1 ✅线程的优先级对程序的性能有什么影响)
    • [1.2 ✅ 线程优先级影响内存使用的原因是什么](#1.2 ✅ 线程优先级影响内存使用的原因是什么)
    • [1.3 ✅优先级越高,线程越容易被调度到吗](#1.3 ✅优先级越高,线程越容易被调度到吗)
    • [1.4 ✅线程的优先级是根据什么决定的呢](#1.4 ✅线程的优先级是根据什么决定的呢)
    • [1.5 ✅如何避免线程优先级和内存使用之间的关联](#1.5 ✅如何避免线程优先级和内存使用之间的关联)
  • 二、✅拓展知识仓
    • [2.1 ✅WAITING和TIMED_WAIT的区别?](#2.1 ✅WAITING和TIMED_WAIT的区别?)
    • [2.2 ✅为什么线程没有RUNNING状态](#2.2 ✅为什么线程没有RUNNING状态)

一、✅典型解析

Java中线程的状态分为六种：

  • 初始(NEW): 新创建了一个线程对象，但还没有调用start()方法。
  • 运行(RUNNABLE): Java线程中将就绪 (READY) 和运行中(RUNNING) 两种状态笼统的称为 " 运行 " 。

就绪(READY) : 线程对象创建后，其他线程(比如main线程) 调用了该对象的start0方法。该状态的线程位于可运行线程池中，等待被线程调度选中并分配cpu使用权。

运行中 (RUNNING): 就绪(READY)的线程获得了cpu 时间片，开始执行程序代码。

  • 阻塞(BLOCKED): 表示线程阻塞于锁 (关于锁，在后面章节会介绍) 。
  • 等待(WAITING): 进入该状态的线程需要等待其他线程做出一些特定动作(通知或中断)。
  • 超时等待(TIMED WAITING): 该状态不同于WAITING，它可以在指定的时间后自行返回。
  • 终止(TERMINATED): 表示该线程已经执行完毕。

状态流转如图:

1.1 ✅线程的优先级对程序的性能有什么影响

线程的优先级对程序的性能有很大影响。影响的一些关键点：

  1. 响应速度和吞吐量：优先级较高的线程在多线程环境中通常能够更快地执行任务，从而提高程序的响应速度和吞吐量。这是因为操作系统会为优先级较高的线程分配更多的CPU时间片，使其能够更快地完成任务。
  2. 执行顺序：在多线程编程中，有些任务需要按照一定的顺序执行。通过设置线程的优先级，可以控制线程的执行顺序，从而满足任务的需求。
  3. 避免线程饥饿：如果某个线程的优先级过低，它可能会长时间得不到足够的CPU资源，从而导致线程饥饿现象。使用线程优先级可以避免这种情况，保证程序的稳定性和正确性。

然而，需要注意的是，过度调整线程优先级可能会带来一些问题。例如，如果将某个线程的优先级设置得过高，可能会导致其他线程得不到足够的CPU资源，从而影响它们的性能。此外，不同的操作系统和线程调度器对线程优先级的处理方式可能不同，因此在实际应用中需要考虑到这些因素。

总的来说，合理地设置线程优先级可以帮助提高程序的性能和响应速度，但需要根据实际应用场景和需求进行适当的调整。在某些情况下，使用默认的线程优先级就已经足够好。

Demo：

java 复制代码 
/**
* @author xinbaobaba
* 使用Java代码来解释线程优先级对程序性能影响的示例
*/

public class ThreadPriorityExample {
    public static void main(String[] args) {
        // 创建三个线程
        Thread threadA = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("Thread A: " + i);
            }
        }, "Thread A");

        Thread threadB = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("Thread B: " + i);
            }
        }, "Thread B");

        Thread threadC = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("Thread C: " + i);
            }
        }, "Thread C");

        // 设置线程优先级
        threadA.setPriority(Thread.MAX_PRIORITY); // 高优先级
        threadB.setPriority(Thread.NORM_PRIORITY); // 正常优先级
        threadC.setPriority(Thread.MIN_PRIORITY); // 低优先级

        // 启动线程
        threadA.start();
        threadB.start();
        threadC.start();
    }
}

代码解析：创建了三个线程，分别命名为"Thread A"、"Thread B"和"Thread C"。然后，我们为这三个线程设置了不同的优先级：Thread A 是高优先级，Thread B 是正常优先级，Thread C 是低优先级。最后，我们启动这三个线程。

由于线程的优先级不同，它们的执行顺序和执行时间也会有所不同。高优先级的线程会比低优先级的线程更快地执行完毕。因此，程序的性能和响应速度会受到线程优先级的影响。

输出结果可能类似于以下内容：

css 复制代码 
Thread A: 0
Thread A: 1
Thread A: 2
... (其他 Thread A 的输出)
Thread B: 0
Thread B: 1
Thread B: 2
... (其他 Thread B 的输出)
Thread C: 0
Thread C: 1
Thread C: 2
... (其他 Thread C 的输出)

可以看到，高优先级的 Thread A 先于其他线程执行，然后是正常优先级的 Thread B，最后是低优先级的 Thread C。这是因为操作系统会根据线程的优先级分配CPU时间片，优先级高的线程会获得更多的CPU时间，从而更快地执行任务。这影响了程序的性能和响应速度。

1.2 ✅ 线程优先级影响内存使用的原因是什么

线程优先级影响内存使用的原因在于，线程在执行过程中需要占用内存资源。具体来说，每个线程在执行时都需要分配一定的内存空间，包括栈空间和堆空间等。线程优先级高的线程会获得更多的CPU时间，从而更快地执行任务，这可能导致优先级高的线程在较短的时间内占用了更多的内存资源。

在多线程程序中，如果大量高优先级的线程同时运行，它们可能会迅速地消耗掉可用的内存资源，导致系统频繁地进行内存分配和垃圾回收操作，这不仅会影响程序的性能，还可能引发内存溢出等问题。因此，合理地设置线程优先级，并配合其他并发控制手段，可以有效地管理内存使用，提高程序的稳定性和性能。

Demo：

首先，要理解Java中的线程优先级，你需要了解Java线程调度器的行为。在Java中，线程调度器是一个在操作系统之上的抽象，它决定了哪些线程可以在特定时间运行。每个线程都有一个优先级，优先级决定了线程调度器在选择要运行的线程时的考虑因素。

Java定义了10个不同的优先级，从Thread.MIN_PRIORITY（1）到Thread.MAX_PRIORITY（10）。默认情况下，所有线程的优先级都是Thread.NORM_PRIORITY（5）。

以下是一个简单的Java代码示例，演示如何设置线程优先级：

java 复制代码 
/**
* @author xinbaobaba
* 如何在Java中使用线程优先级以及如何通过调整线程优先级来影响内存使用
*/
public class ThreadPriorityExample {
    public static void main(String[] args) {
        // 创建线程并设置优先级
        Thread threadA = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("Thread A: " + i);
            }
        });
        threadA.setPriority(Thread.MAX_PRIORITY); // 设置线程A的优先级为最高

        Thread threadB = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("Thread B: " + i);
            }
        });
        threadB.setPriority(Thread.NORM_PRIORITY); // 设置线程B的优先级为正常

        Thread threadC = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                System.out.println("Thread C: " + i);
            }
        });
        threadC.setPriority(Thread.MIN_PRIORITY); // 设置线程C的优先级为最低

        // 启动线程
        threadA.start();
        threadB.start();
        threadC.start();
    }
}

现在，关于如何通过调整线程优先级来影响内存使用，这里有一些考虑因素：

  1. 堆栈大小：线程的优先级会影响到JVM为其分配的堆栈大小。高优先级的线程通常会获得更大的堆栈空间。如果大量高优先级的线程同时运行，它们可能会消耗掉大量的内存资源。因此，在设置线程优先级时，需要考虑到程序的内存需求和可用内存。
  2. 上下文切换：高优先级的线程更容易获得CPU时间，这意味着它们更频繁地运行和休眠，这可能导致更多的上下文切换。上下文切换需要保存和恢复线程的执行环境，这会增加CPU的负载和内存消耗。因此，不当地设置线程优先级可能会对程序的性能产生负面影响。
  3. 垃圾回收：当一个线程分配了大量的内存空间时，垃圾回收器需要更频繁地运行以回收不再使用的内存。这可能会导致垃圾回收器在高优先级线程活跃时运行得更加频繁，从而影响程序的性能。因此，在设计多线程程序时，应该注意控制内存分配，以减少垃圾回收的频率和影响。

1.3 ✅优先级越高,线程越容易被调度到吗

优先级越高的线程在大多数操作系统中更容易被调度。优先级决定了线程在调度时的优先顺序，优先级高的线程会比优先级低的线程获得更多的CPU时间。

注意：优先级高的线程并不一定总是先于低优先级的线程执行。线程调度器会根据调度算法和系统负载等多种因素来决定线程的执行顺序。此外，不同的操作系统和硬件平台可能会有不同的调度行为。

因此，虽然优先级高的线程更容易被调度，但并不能保证它们一定先于低优先级的线程执行。在设计程序时，应该避免过度依赖线程优先级来优化性能，而是应该综合考虑代码设计、数据结构和算法优化、同步机制等方面的因素。

Demo：

java 复制代码 
import java.util.concurrent.*;

/**
* @author xinbaobaba
* 如何使用Java的并发工具和内存管理机制来优化内存使用和程序性能
*/
public class ComplexThreadPriorityExample {
    public static void main(String[] args) {
        // 创建一个固定大小的线程池
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // 创建任务并提交到线程池执行
        Future<?> futureA = executor.submit(() -> {
            // 模拟内存密集型任务
            for (int i = 0; i < 1000; i++) {
                System.out.println("Task A: " + i);
            }
        });

        Future<?> futureB = executor.submit(() -> {
            // 模拟CPU密集型任务
            int sum = 0;
            for (int i = 0; i < 100000; i++) {
                sum += i; // 模拟CPU密集型计算任务
            }
            System.out.println("Task B: " + sum);
        });

        Future<?> futureC = executor.submit(() -> {
            // 模拟I/O密集型任务
            try {
                Thread.sleep(5000); // 休眠5秒，模拟I/O密集型任务等待时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Task C: Completed");
        });

        // 获取任务的执行结果（如果需要）
        try {
            System.out.println("Task A result: " + futureA.get()); // 等待任务A执行完成并获取结果（如果有返回值）
            System.out.println("Task B result: " + futureB.get()); // 等待任务B执行完成并获取结果（如果有返回值）
            System.out.println("Task C result: " + futureC.get()); // 等待任务C执行完成并获取结果（如果有返回值）
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池，释放资源
            executor.shutdown();
        }
    }
}

代码解析：使用了Java的ExecutorService来创建固定大小的线程池，并提交任务到线程池执行。这样可以更好地管理线程的执行，避免线程过多导致资源竞争和内存问题。每个任务模拟了不同类型的任务：内存密集型、CPU密集型和I/O密集型。通过合理地组织任务的执行顺序和利用线程池，我们可以优化内存使用和程序性能。

1.4 ✅线程的优先级是根据什么决定的呢

线程的优先级是根据多种因素决定的，其中一些因素包括线程的属性、任务紧急程度、线程的执行历史记录等。在Java中，线程优先级是一个从1到10的整数，其中1是最低优先级，10是最高优先级。默认情况下，线程的优先级为5。线程优先级是调度程序选择运行哪个线程的一个关键因素。调度程序会根据优先级、任务的紧急程度和其他因素来决定线程的执行顺序。高优先级的线程通常会更有可能获得CPU时间，而低优先级的线程可能会被调度程序推迟执行。需要注意的是，线程优先级并不能保证线程的执行顺序，因为线程的执行还受到其他因素的影响，如系统负载、其他线程的执行情况等。

1.5 ✅如何避免线程优先级和内存使用之间的关联

为了避免线程优先级和内存使用之间的关联，可以采取以下措施：

  1. 合理设置线程优先级：不要过度依赖线程优先级来优化性能。优先级高的线程可能会获得更多的CPU时间，但并不意味着它可以更有效地使用内存。相反，过度调整线程优先级可能会导致线程调度的不稳定和其他问题。
  2. 使用适当的同步机制：当多个线程访问和修改共享资源时，需要使用适当的同步机制（如互斥锁、条件变量等）来避免死锁和资源竞争。这样可以确保线程安全地访问内存，并减少不必要的内存占用。
  3. 优化数据结构和算法：通过优化数据结构和算法，可以减少线程对内存的需求。例如，使用更高效的数据结构、减少不必要的内存分配等。
  4. 使用内存管理工具：使用操作系统提供的内存管理工具来监控和分析内存使用情况。这可以帮助你识别和解决内存泄漏、过度分配等问题。
  5. 编写良好的并发代码：编写高质量的并发代码可以减少线程间的竞争和同步问题，从而降低内存使用的风险。遵循最佳实践，如避免数据竞态条件、正确使用锁等。
  6. 测试和性能分析：通过测试和性能分析来评估线程优先级和内存使用之间的关系。通过收集性能数据并进行分析，可以找到潜在的性能瓶颈和内存问题，并采取相应的优化措施。

总之，避免线程优先级和内存使用之间的关联需要综合考虑多个方面，包括代码设计、同步机制、数据结构和算法优化等。通过合理的编程实践和性能分析，可以有效地管理内存并提高程序的性能。

Demo：

当涉及到线程优先级和内存使用之间的关联时，Java 提供了丰富的并发编程工具和内存管理机制。

java 复制代码 
/**
* @author xinbaobaba
* 使用Java代码来解释如何避免线程优先级和内存使用之间关联
*/
public class ThreadPriorityExample {
    public static void main(String[] args) {
        // 创建三个线程
        Thread threadA = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                // 模拟内存密集型任务
                System.out.println("Thread A: " + i);
                try {
                    Thread.sleep(100); // 休眠100毫秒，模拟内存密集型任务
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Thread A");

        Thread threadB = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                // 模拟CPU密集型任务
                System.out.println("Thread B: " + i);
                int sum = 0;
                for (int j = 0; j < 10000; j++) {
                    sum += j; // 模拟CPU密集型计算任务
                }
            }
        }, "Thread B");

        Thread threadC = new Thread(() -> {
            for (int i = 0; i < 1000; i++) {
                // 模拟I/O密集型任务
                System.out.println("Thread C: " + i);
                try {
                    Thread.sleep(500); // 休眠500毫秒，模拟I/O密集型任务
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }, "Thread C");

        // 设置线程优先级（但Java不推荐设置线程优先级）
        // threadA.setPriority(Thread.MAX_PRIORITY); // 高优先级
        // threadB.setPriority(Thread.NORM_PRIORITY); // 正常优先级
        // threadC.setPriority(Thread.MIN_PRIORITY); // 低优先级

        // 启动线程（使用Executor框架）
        ExecutorService executor = Executors.newFixedThreadPool(3); // 创建固定大小的线程池
        executor.execute(threadA); // 提交线程任务到线程池执行
        executor.execute(threadB);
        executor.execute(threadC);
        executor.shutdown(); // 关闭线程池，等待所有任务执行完毕
    }
}

代码解析：创建了三个线程：Thread A、Thread B 和 Thread C，分别模拟内存密集型、CPU密集型和I/O密集型任务。我们没有设置线程优先级，而是使用了Java的Executor框架来管理线程的执行。通过这种方式，我们避免了直接设置线程优先级，而是通过合理地组织任务的执行顺序和利用线程池来优化内存使用。

注意：Java并不推荐直接设置线程优先级，因为不同的JVM实现和操作系统可能会有不同的行为。相反，推荐使用Java提供的并发工具和内存管理机制来优化内存使用和程序性能。

二、✅拓展知识仓

2.1 ✅WAITING和TIMED_WAIT的区别?

WAITING是等待状态，在Java中，调用wait方法时，线程会进入到WAITING状态，而TIMED_WAITING是超时等待状态，当线程执行sleep方法时，线程会进入TIMED_WAIT状态

处于WAITING和TIMED_WAIT的线程，都是会让出CPU的，这时候其他线程就可以获得CPU时间片开始执行。但是他们在对象的锁释放上面并不一样，如果加了锁，sleep方法不会释放对象上的锁，而wait方法是会释放锁的。

因为Java锁的目标是对象，所以wait、notifv和notifyAll针对的目标都是对象，所以把他们定义在Object类中。而sleep不需要释放锁，所以他是Thread类中的一人方法。

2.2 ✅为什么线程没有RUNNING状态

对于现在的分时操作系统来说，在单CPU情况下，所有的线程其实都是串行执行的。但是为了让我们看起来像是在并发执行，人们把CPU的执行分成很多个小的时间片。

哪个线程得到时间片，那个线程就执行，时间片到了之后，就要释放出CPU，再重新进行争抢时间片。

只要把时间片划分的足够细，那么多个程序虽然在不断的串行执行，但是看起来也像是在同时执行样。

那么，CPU的时间片其实是很短的，一般也就是10-20毫秒左右。

那么，也就是说，在一秒钟之内，同一个线程可能一部分时间处于READY状态、一部分时间处于RUNNING状态。

那么如果，明确的给线程定义出RUNNING状态的话，有一个很大的问题，就是这个状态其实是不准的。

因为当我们看到线程是RUNNING状态的时候，很有可能他已经丢失了CPU时间片了。

对于线程的状态，我们只需要知道，他当前有没有在"正在参与执行"就行了，何为"参与执行"?

就是他的状态是可执行的，只要获得时间片，就能立即执行。

那这不就是RUNNABLE吗?

所以，Java就没有给线程定义RUNNING状态，而是定义了一个RUNNABLE状态

相关推荐
老猿讲编程15 分钟前
一个例子来说明Ada语言的实时性支持
开发语言·ada
Chrikk1 小时前
Go-性能调优实战案例
开发语言·后端·golang
幼儿园老大*1 小时前
Go的环境搭建以及GoLand安装教程
开发语言·经验分享·后端·golang·go
canyuemanyue1 小时前
go语言连续监控事件并回调处理
开发语言·后端·golang
杜杜的man1 小时前
【go从零单排】go语言中的指针
开发语言·后端·golang
测开小菜鸟1 小时前
使用python向钉钉群聊发送消息
java·python·钉钉
P.H. Infinity2 小时前
【RabbitMQ】04-发送者可靠性
java·rabbitmq·java-rabbitmq
生命几十年3万天2 小时前
java的threadlocal为何内存泄漏
java
caridle3 小时前
教程：使用 InterBase Express 访问数据库（五）：TIBTransaction
java·数据库·express
萧鼎3 小时前
Python并发编程库：Asyncio的异步编程实战
开发语言·数据库·python·异步
热门推荐
01如何才能让手机厂商主动拥抱华为，接入鸿蒙系统？02【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04Macbook pro M1 安装Ubuntu教程05(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明06【经验分享】Ubuntu22.04安装微信(linux官方版)07文件或文件夹名称中有空格如何批量去除08全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）09RAG 实践- Ollama+RagFlow 部署本地知识库10基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测