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

在这里插入图片描述

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


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


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


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


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

  • 一、✅典型解析
    • 1.1 ✅线程的优先级对程序的性能有什么影响
    • 1.2 ✅ 线程优先级影响内存使用的原因是什么
    • 1.3 ✅优先级越高,线程越容易被调度到吗
    • 1.4 ✅线程的优先级是根据什么决定的呢
    • 1.5 ✅如何避免线程优先级和内存使用之间的关联
  • 二、✅拓展知识仓
    • 2.1 ✅WAITING和TIMED_WAIT的区别?
    • 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：


/**
* @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 是低优先级。最后，我们启动这三个线程。


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


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


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代码示例，演示如何设置线程优先级：



/**
* @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：


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 提供了丰富的并发编程工具和内存管理机制。



/**
* @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状态


本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/320678.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

什么是信噪比

什么是信噪比

大家好&#xff0c;今天给大家介绍什么是信噪比&#xff0c;文章末尾附有分享大家一个资料包&#xff0c;差不多150多G。里面学习内容、面经、项目都比较新也比较全&#xff01;可进群免费领取。 “信噪比”是电子技术中经常用到的一个词组&#xff0c;知道它的确切含义有一定意…
阅读更多...
Day02

Day02

今日任务&#xff1a; 977 有序数组的平方209 长度最小的子数组59 螺旋矩阵Ⅱ 977 有序数组的平方 题目链接&#xff1a;https://leetcode.cn/problems/squares-of-a-sorted-array/ 双指针问题&#xff0c;以及数组本身时有序的&#xff1b; 思路&#xff1a; 左、右两个…
阅读更多...
unet脑肿瘤分割完整代码

unet脑肿瘤分割完整代码

U-net脑肿瘤分割完整代码 代码目录数据集网络训练测试 代码目录 数据集 https://www.kaggle.com/datasets/mateuszbuda/lgg-mri-segmentation dataset.py 在这里插入代码片import os import numpy as np import glob from PIL import Image import cv2 import torchvision fr…
阅读更多...
如何在“Microsoft Visual Studio”中使用OpenCV构建应用程序

如何在“Microsoft Visual Studio”中使用OpenCV构建应用程序

我在这里描述的所有内容都将应用于 OpenCV 的界面。我首先假设您已经阅读并成功完成了 Windows 中的安装教程。因此&#xff0c;在进一步操作之前&#xff0c;请确保您有一个包含 OpenCV 头文件和二进制文件的 OpenCV 目录&#xff0c;并且您已按照此处所述设置环境变量 设置 O…
阅读更多...
多智能体强化学习（概念知识，不涉及具体算法）

多智能体强化学习（概念知识，不涉及具体算法）

目录 一、前置知识1.factored value function2.partially observable MDP (POMDP) problem.2.2 Decentralized-POMDP problem2.3 networked decentralized partially observable Markov decision processes (ND-POMDP) problem2.4 上述两种算法的区别 3. Mean Field Multi-Agen…
阅读更多...
深信服超融合HCI版本升级，6.0.0R5升级至6.8.0R2

深信服超融合HCI版本升级，6.0.0R5升级至6.8.0R2

超融合升级&#xff0c;需要满足以下条件及前期准备&#xff1a; 确认HCI的升级序列号有效升级时长大概在一个半小时&#xff0c;安全起见&#xff0c;需预留至少三至四小时窗口期升级前&#xff0c;需要将所有虚拟机关机&#xff0c;涉及到业务无法访问&#xff0c;需提前通知…
阅读更多...
redis中的string相关的部分命令

redis中的string相关的部分命令

redis命令手册 redis中文官网查看文档 挨个进行输出调试 Redis Setnx 命令 Redis Getrange 命令 Redis Mset 命令 redis 127.0.0.1:6379> MSET key1 "Hello" key2 "World" OK redis 127.0.0.1:6379> GET key1 "Hello" redis 127.0.0.1:…
阅读更多...
datavrap-各种各样的条形图（含详细操作步骤）

datavrap-各种各样的条形图（含详细操作步骤）

静态条形图&#xff1a;正确设置数据即可&#xff0c;导出的图形不会随着时间变化 最普通的静态条形图 黑色系风格的静态条形图 动态条形图&#xff1a;导出的图形会随着时间变化 普通的动态条形图 带数字滚动效果的动态条形图 简单的Top排行榜动态条形图 格式更丰富的Top排行榜…
阅读更多...
牛客周赛 Round 28 解题报告 | 珂学家 | 组合数学 + 离散化树状数组

牛客周赛 Round 28 解题报告 | 珂学家 | 组合数学 + 离散化树状数组

前言 整体评价 还是E稍微有点意思&#xff0c;新周赛好像比预期要简单一些, _. 欢迎关注 珂朵莉 牛客周赛专栏 珂朵莉 牛客小白月赛专栏 A. 小红的新周赛 思路: 模拟 #include <bits/stdc.h>using namespace std;int main() {int res 0;for (int i 0; i < 6; i…
阅读更多...
【算法练习】leetcode算法题合集之数组和哈希表篇

【算法练习】leetcode算法题合集之数组和哈希表篇

重建数组&#xff08;高频&#xff09; LeetCode283.移动零 LeetCode283.移动零 双指针&#xff0c;记录已经处理好的序列的尾部 class Solution {public void moveZeroes(int[] nums) {int k 0;for (int i 0; i < nums.length; i) {if (nums[i] ! 0) {swap(nums, i, k)…
阅读更多...
【前后端的那些事】开源！前后端环境搭建+树形结构表格实现

【前后端的那些事】开源！前后端环境搭建+树形结构表格实现

文章目录 1. 前后端项目环境搭建2. table-tree2.1 后端准备2.2 前端准备 前言&#xff1a;最近写项目&#xff0c;发现了一些很有意思的功能&#xff0c;想写文章&#xff0c;录视频把这些内容记录下。但这些功能太零碎&#xff0c;如果为每个功能都单独搭建一个项目&#xff0…
阅读更多...
Python之Matplotlib绘图调节清晰度

Python之Matplotlib绘图调节清晰度

Python之Matplotlib绘图调节清晰度 文章目录 Python之Matplotlib绘图调节清晰度引言解决方案dpi是什么&#xff1f;效果展示总结 引言 使用python中的matplotlib.pyplot绘图的时候&#xff0c;如果将图片显示出来&#xff0c;或者另存为图片&#xff0c;常常会出现清晰度不够的…
阅读更多...
前端js写数据结构与算法

前端js写数据结构与算法

1、什么是数据结构与算法 数据结构&#xff1a;是指数据对象中数据元素之间的相互关系。包括集合结构、线性结构、树形结构、图形结构。 算法&#xff1a;解决问题的思路。 2、时间复杂度 1.是什么? 执行当前算法所“花费的时间” 2.干什么? 在写代码的过程中&#xf…
阅读更多...
网工内推 | 信息安全主管，CISP/CISSP认证优先，最高25K

网工内推 | 信息安全主管，CISP/CISSP认证优先，最高25K

01 武汉华康世纪医疗股份有限公司 招聘岗位&#xff1a;网络安全主管 职责描述&#xff1a; 1、推进公司信息/网络安全管理体系规划、建设、持续改进&#xff0c;促进信息安全管理的推行落地,保障网络、系统与数据安全&#xff1b; 2、维护管理信息/网络管理软件&#xff0c;设…
阅读更多...
CSP网络结构实战 - 降低计算量的特征融合方式

CSP网络结构实战 - 降低计算量的特征融合方式

CSP网络结构实战 - 降低计算量的特征融合方式 CSP网络结构实战 - 降低计算量的特征融合方式0. 引言1. CSP网络结构简介1.1 核心思想1.2 解决的问题 2. 实验验证2.1 CSP网络模型构建2.2 数据读取与预处理2.3 模型训练与验证 3. 对比实验4. 结果与总结 CSP网络结构实战 - 降低计算…
阅读更多...
RT-DETR算法优化改进：多层次特征融合（SDI）结合PConv、DualConv、GSConv，实现二次创新 | UNet v2最新论文

RT-DETR算法优化改进：多层次特征融合（SDI）结合PConv、DualConv、GSConv，实现二次创新 | UNet v2最新论文

💡💡💡本文独家改进：多层次特征融合（SDI）高效结合DualConv、PConv、GSConv等实现二次创新 1)替代原始的Concat； RT-DETR魔术师专栏介绍： https://blog.csdn.net/m0_63774211/category_12497375.html ✨✨✨魔改创新RT-DETR 🚀🚀🚀引入前沿顶会创新（CVPR…
阅读更多...
从零开始做题：逆向wdb_2018_2nd_easyfmt

从零开始做题：逆向wdb_2018_2nd_easyfmt

1.题目信息 2.解题分析 格式化字符串漏洞 如何确定偏移 Do you know repeater? 输入AAAA.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p. 输出AAAA.0xffffd658.0x64.0xf7ffdc08.0xf7ffcd00.0xffffd77c.0x41414141.0x2e70252e.0x252e7025.0x70252e70.0x2e70252e.0x252e7025.0x70252…
阅读更多...
【数据结构】排序算法

【数据结构】排序算法

&#x1f984;个人主页:修修修也 &#x1f38f;所属专栏:数据结构 ⚙️操作环境:Visual Studio 2022 目录 &#x1f38f;排序的定义 &#x1f38f;排序的稳定性 &#x1f4cc;稳定性的定义 &#x1f4cc;稳定性的意义 &#x1f38f;内排序与外排序 &#x1f38f;八大内排…
阅读更多...
Linux环境基础开发工具的使用（上）

Linux环境基础开发工具的使用（上）

文章目录 Linux 软件包管理器 yum什么是软件包关于rzsz查看软件包安装软件卸载软件 Linux编辑器 - vimvim的基本概念vim下各模式的切换vim命令模式各命令汇总vim底行模式各命令汇总 配置vim Linux 软件包管理器 yum 什么是软件包 在Linux下安装软件, 一个通常的办法是下载到程…
阅读更多...
Vue实战：两种方式创建Vue项目

Vue实战：两种方式创建Vue项目

文章目录 一、实战概述二、实战步骤&#xff08;一&#xff09;安装Vue CLI脚手架1、从Node.js官网下载LTS版本2、安装Node.js到指定目录3、配置Node.js环境变量4、查看node版本5、查看npm版本6、安装Vue Cli脚手架7、查看Vue Cli版本 &#xff08;二&#xff09;命令行方式构建…
阅读更多...
最新文章

Copyright @ 2022~2023