【Linux系统】进程状态 | 进程优先级

Ronin3052025-07-14 14:38

I. 进程状态

进程状态的概念介绍

进程状态是操作系统用来描述进程在生命周期中不同活动阶段的核心概念。进程在执行过程中会因资源请求、事件等待或调度策略而改变状态，这些状态反映了进程的当前行为（如运行、等待或终止）。状态转换由操作系统内核管理，确保系统资源高效分配。例如，一个进程可能从"运行"状态切换到"阻塞"状态以等待用户输入，事件完成后又回到"运行"状态。理解进程状态有助于分析系统性能，如CPU利用率或响应延迟。

举例帮助理解 ：

想象一个简单的文本编辑器进程：

  • 当用户输入文字时，进程处于 运行状态（CPU执行编辑操作）。
  • 如果用户暂停输入，进程进入 阻塞状态（等待键盘事件）。
  • 若系统内存不足，操作系统可能将进程换出到磁盘，进入 挂起状态（释放内存，但保留进程数据）。
  • 用户关闭编辑器时，进程终止并短暂成为 僵尸状态 （等待父进程回收资源），最终变为 死亡状态。

这个例子展示了状态如何随事件（用户操作、资源变化）动态转换，体现了操作系统的调度机制。

1. Linux进程状态的内核定义

1. 内核源码中的状态定义

Linux内核源代码（如task_state_array）明确定义了进程状态，这些状态存储在进程控制块（PCB）的字段中，用宏表示不同数值。以下是关键状态及其含义：

  • R (running) : 进程正在CPU执行或在运行队列中等待调度。注意：它不一定是当前运行中，而是"可运行"状态。示例 ：CPU密集型循环（如while(1);）的进程状态为R+，而含printf的循环因等待显示器就绪变为S+。
  • S (sleeping) : 可中断睡眠状态，进程等待事件（如I/O完成或信号），可被外部信号唤醒。例如，scanf等待输入。
  • D (disk sleep): 不可中断睡眠状态，进程等待硬件操作（如磁盘I/O），不能被信号中断。若强行终止，可能导致数据损坏。例如，数据库进程写入磁盘时进入此状态。
  • T (stopped) : 暂停状态，进程被信号（如SIGSTOP）强制停止，可通过SIGCONT恢复。调试程序时常见此状态。
  • Z (zombie) : 僵尸状态，进程已终止但PCB未被父进程回收，占用少量内存资源。例如，父进程未调用wait()时，子进程残留为僵尸。
  • X (dead): 死亡状态，进程完全终止且资源已释放，不会出现在任务列表中。

源代码片段参考：

cpp 复制代码 
static const char *const task_state_array[] = {
    "R (running)", /*0 */  // 运行或就绪
    "S (sleeping)", /*1 */  // 可中断睡眠
    "D (disk sleep)", /*2 */ // 不可中断睡眠
    "T (stopped)", /*4 */   // 停止
    "t (tracing stop)", /*8 */ // 跟踪停止（调试）
    "X (dead)", /*16 */     // 死亡
    "Z (zombie)", /*32 */   // 僵尸
};

此定义体现了Linux状态设计的"位图"特性（如状态值可组合），便于内核进行高效位测试。

2. 状态转换触发条件

转换路径 触发场景
R → S 进程执行阻塞操作（如sleep()、read()等待I/O）16
S → R 等待的资源就绪（如I/O完成）或被信号唤醒6
R → D 发起不可中断的系统调用（如同步磁盘写入）3
R → T 收到SIGSTOP或Ctrl+Z
T → R 收到SIGCONT信号1
R → Z 子进程exit()后父进程未回收7

案例解释 ：

若vim编辑文件时磁盘故障，进程进入D状态。此时kill无效，需重启或修复硬件3。而后台下载工具因网络中断进入S状态，网络恢复后自动唤醒。

2. 运行、阻塞、挂起：进程状态的本质剖析

运行状态（Running）

  • 概念 ：进程正在CPU执行或位于运行队列中准备执行。在Linux中对应R状态，强调"可调度性"而非实际占用CPU。
  • 细节 ：
    • 运行队列（run_queue）存储所有可运行进程的PCB，调度器从中选择进程分配CPU时间片。
    • 若进程被更高优先级进程抢占，会返回运行队列等待。
    • 示例：多任务系统中，浏览器和音乐播放器进程交替进入运行状态，共享CPU资源。

阻塞状态（Blocked）

  • 概念 ：进程因等待资源（如I/O、信号）而暂停执行，分为两类：
    • 可中断阻塞（S状态） ：可被信号唤醒（如SIGKILL）。例如，网络下载进程等待数据包时休眠，收到取消信号后立即退出。
    • 不可中断阻塞（D状态） ：仅由特定事件（如硬件操作完成）唤醒，避免数据不一致。例如，文件系统进程写入磁盘时不可中断。
  • 与运行状态关系：阻塞是运行的反面------进程因资源短缺退出运行队列，加入等待队列。

挂起状态（Suspended）

  • 概念：进程被操作系统移出内存（换到磁盘（Swap分区）），释放物理内存资源。挂起常与阻塞关联（挂起必阻塞，但阻塞未必挂起）。

  • 细节 ：

    • Linux未直接定义挂起状态，但通过机制（如交换空间）实现：当内存不足时，内核将阻塞进程挂起。
    • 唤醒时，进程需从磁盘加载回内存，再进入就绪队列。
    • 示例：大型编译任务在后台运行时，若系统内存紧张，可能被挂起；用户切回时重新加载，继续执行。

  • 双重状态：

    • 阻塞且挂起：进程数据在磁盘，等待资源

    • 就绪但挂起：进程数据在磁盘，可运行但需先换入内存

风险提示：频繁挂起预示内存枯竭，可能触发OOM Killer强制杀进程。

状态转换示例 ：

一个视频编码进程：

  1. 运行：编码时占用CPU（R状态）。
  2. 阻塞：读取大文件时等待磁盘I/O（进入S或D状态）。
  3. 挂起：若系统负载高，进程被换出到磁盘（隐含阻塞）。
  4. 唤醒 ：磁盘操作完成，进程加载回内存，返回运行队列（R状态）。
    此过程展示了资源竞争如何驱动状态转换。

3. PCB存储结构与组织方式

PCB（task_struct）的核心作用

PCB是Linux内核中task_struct结构体，存储进程所有元数据（如状态、优先级、内存映射）。它是进程的唯一标识，通过链表和队列实现状态管理：

cpp 复制代码 
struct task_struct {
    volatile long state;      // 进程状态（0=R,1=S,...）
    struct mm_struct *mm;     // 内存管理结构（含代码/数据地址）
    pid_t pid;                // 进程ID
    struct files_struct *files; // 打开文件表
    // 以上我们现在先不用去关心
    // 这次介绍的重点 struct list_head
    struct list_head tasks;   // 链表节点（用于组织队列）
    // ...（优先级、调度策略、寄存器值等）
};
  • 存储结构 ：
    • 状态字段 ：state变量存储当前状态值（如TASK_RUNNING宏对应R状态）。
    • 队列指针 ：PCB包含next和prev指针，链接到运行队列或阻塞队列。
    • 其他成员：包括调度信息（优先级）、资源句柄（打开文件）、父子进程指针等。

我们来看看struct list_head

cpp 复制代码 
struct list_head {
    struct list_head *next, *prev;
};

这个极简结构只有两个指针：

  • next：指向下一个节点

  • prev：指向前一个节点

设计哲学："侵入式链表" - 链表节点嵌入宿主结构体，而非包裹数据

I. 宿主结构体获取

cpp 复制代码 
// Linux2.0内核版本
#define container_of(ptr, type, member) \
    ((type *)((char *)(ptr) - (unsigned long)(&((type *)0)->member)))

container_of宏是Linux内核中最重要的基础宏之一，它实现了通过结构体成员地址获取整个结构体地址的神奇功能。让我们逐层解剖这个精妙的设计。

一、宏参数说明
参数 类型 作用
ptr 指针 指向结构体成员的指针
type 数据类型 目标结构体的类型
member 成员名 结构体中该成员的名称
二、工作原理详解

步骤1：计算成员偏移量（offsetof）

cpp 复制代码 
&((type *)0)->member

操作分解：

  1. (type *)0：将0地址强制转换为指向type类型的指针

    • 效果：假设地址0处存在一个type类型的结构体实例

  2. ->member：访问该"虚拟结构体"的成员

    • 关键 ：此时成员member的地址就是其相对于结构体起始位置的偏移量

  3. &：取该成员的地址

    • 结果：得到成员member在结构体中的偏移字节数

示例 ：计算task_struct中tasks成员的偏移

cpp 复制代码 
struct task_struct {
    // ...
    struct list_head tasks;
    // ...
};

size_t offset = (unsigned long)&((struct task_struct *)0)->tasks;

步骤2：类型转换与指针运算

cpp 复制代码 
(char *)(ptr) - (unsigned long)(/*偏移量*/)

操作分解：

  1. (char *)(ptr)：将成员指针转换为char*类型

    • 目的：进行字节级指针运算（char类型保证按字节计算）

  2. - (unsigned long)(/*偏移量*/)：从成员地址减去偏移量

    • 结果：得到包含该成员的结构体起始地址

步骤3：类型转换回目标结构体

cpp 复制代码 
((type *) /* 计算出的地址 */)

  • 将计算出的地址转换回type*类型

  • 得到指向完整结构体的指针

三、完整计算过程图示
cpp 复制代码 
内存布局示意图：

结构体起始地址
+---------------------+  <---- struct task_struct *
|     其他成员         |
|                     |
+---------------------+  <---- &((struct task_struct*)0)->tasks
|   struct list_head  |  \
|      tasks          |   | 偏移量 = 此地址 - 0
|   (next, prev)      |  /
+---------------------+
|      其他成员        |
|                     |
+---------------------+

计算过程：

  1. 已知tasks成员的地址：ptr = 0x1008

  2. 计算偏移量：offset = 0x200（假设值）

  3. 结构体起始地址 = ptr - offset = 0x1008 - 0x200 = 0x0E08

II. 在内核中的实际应用

1. 进程管理
cpp 复制代码 
// kernel/sched/core.c
struct task_struct {
    struct list_head tasks;       // 全局进程链表
    struct list_head children;    // 子进程链表
    struct list_head sibling;     // 兄弟进程链表
    // ...
};
2. 页面管理
cpp 复制代码 
// mm_types.h
struct page {
    struct list_head lru;         // 页面缓存链表
    // ...
};
3. 文件系统
cpp 复制代码 
// fs.h
struct super_block {
    struct list_head s_list;      // 超级块链表
    // ...
};

struct inode {
    struct list_head i_sb_list;   // 超级块中的inode链表
    // ...
};

4. Z(zombie)-僵尸进程

一、僵尸状态的定义

  1. 本质 ：

    进程完成执行后，其代码和数据占用的内存资源会被系统释放，但进程控制块（PCB）仍被保留在操作系统的进程表中，等待父进程查询其退出状态（如退出码、资源使用统计等）。

    • 此时进程不再消耗CPU或内存资源，仅占用一个 进程ID（PID） 和进程表项。
    • 在系统状态查看工具（如ps）中，此类进程标记为 Z 或 Zombie 。

  2. 触发条件 ：

    子进程终止 → 父进程仍在运行 → 父进程未主动获取子进程退出信息 → 子进程进入僵尸状态。

    • 关键点 ：僵尸状态是父子进程协同机制的结果，而非子进程自身行为错误。

二、为什么需要僵尸状态？

僵尸状态的存在是操作系统的设计必然，原因如下：

  1. 保存退出信息 ：

    子进程退出时需向父进程传递终止原因（如正常退出码、被信号杀死等）。若父进程未及时读取，系统需临时保存这些信息。

    类比示例：快递员（子进程）将包裹（退出状态）送达收件人（父进程）后，需等待签收确认。若收件人未签收，包裹需暂存仓库（进程表），快递员状态即为"待确认"（Zombie）。

  2. 父进程的知情权 ：

    父进程可能依赖子进程的退出状态决策后续操作（例如：

    • Shell中通过$?获取上一条命令的退出码；
    • 服务监控程序需判断子进程是否异常崩溃）。
      若系统直接回收子进程，这些信息将丢失。

  3. 资源释放的中间态 ：

    进程终止需分两步：

    • 释放内存与文件资源（子进程退出时完成）；
    • 释放PCB资源 （父进程读取状态后由系统回收）。
      僵尸状态即第二步未完成时的"半释放"状态。

三、生动示例：模拟僵尸进程

假设编写以下C程序：

cpp 复制代码 
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        //child
        int count = 5;
        while(count)
        {
            printf("我是子进程，我正在运行: %d\n", count);
            sleep(1);
            count--;
        }
    }
    else 
    {
        // father
        while(1)
        {
            printf("我是父进程，我正在运行...\n");
            sleep(1);
        }
    }

    return 0;
}

然后我们使用ps指令来检测一下，每隔一秒检测一次

bash 复制代码 
while :; do ps axj | head -1 && ps axj | grep myprocess | grep -v grep; sleep 1; echo "######" ; done

指令结构拆解

bash 复制代码 
while :; do 
    ps axj | head -1 && 
    ps axj | grep myprocess | grep -v grep; 
    sleep 1; 
    echo "######"; 
done

1. while :; do ... done：无限循环

  • : 是 Bash 中的空命令（永远返回真值），因此 while : 表示永久循环。
  • 作用 ：持续执行 do 和 done 之间的命令，直到手动终止（如 Ctrl+C）。

2. ps axj | head -1：显示进程表头

  • ps axj ：列出系统中所有进程的详细信息 （a 显示所有用户进程，x 包含无终端的进程，j 以作业格式输出）。
  • | head -1 ：管道截取第一行（即列标题：PPID, PID, PGID, STAT 等）。
  • 作用：每次循环先输出表头，明确后续数据的含义。

3. ps axj | grep myprocess | grep -v grep：过滤目标进程

  • ps axj | grep myprocess ：搜索进程列表中包含 "myprocess" 的行。
  • | grep -v grep ：排除 grep 命令自身 （因 grep 运行时也会匹配 "myprocess"）。
  • 作用 ：精准显示 myprocess 进程的状态信息（如 PID, STAT 等）。

4. sleep 1：控制刷新频率

  • 暂停 1 秒，使循环每秒执行一次。
  • 作用：避免高频刷新消耗资源，平衡实时性与性能。

5. echo "######"：输出分隔符

  • 打印 ###### 作为视觉分隔线。
  • 作用：区分每次循环的输出块，提升可读性。

运行结果：

运行结果分析：

  1. 子进程终止 ：

    子进程循环5次后退出（return 0），释放内存和文件资源 ，但PCB（进程控制块）保留 。
    关键机制 ：父进程未调用wait()/waitpid()回收退出状态，子进程进入 僵尸状态（Z） 。

  2. 父进程行为 ：

    继续无限循环，完全未感知子进程终止，持续打印运行信息。

  • 特征：

    • 子进程STAT=Z（僵尸）。
    • 命令列显示[myprocess] <defunct>（"defunct"表示已终止）。
    • PPID仍为父进程PID（605109） ，表明父进程存活但未履行回收责任。

  • 僵尸进程持久化 ：

    只要父进程不终止或主动回收，子进程的僵尸状态会一直存在 ，占用PID和进程表项。
    危害 ：若系统中僵尸进程过多，进程表资源耗尽 → 新进程无法创建。

四、僵尸进程的影响

  1. 短期无害，长期需警惕：

    • 僵尸进程本身不消耗CPU/内存，仅占用少量内核资源（如PID）。
    • 但若父进程长期不回收子进程，僵尸进程累积将耗尽进程表，导致系统无法创建新进程。
    • 典型场景：服务器程序频繁创建子进程但未正确处理退出状态。

5. 孤儿进程

一、孤儿进程的本质

想象一个场景：父母突然消失，孩子被社会福利机构接管。在Linux系统中：

  • 孤儿进程：父进程提前终止，仍在运行的子进程

  • 领养机制 ：内核将孤儿进程的父进程设置为init(PID=1)或systemd

  • 回收保障：由领养进程负责子进程退出后的资源回收

关键点 ：孤儿进程是运行中的活进程，不是僵尸进程

二、验证孤儿进程

cpp 复制代码 
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        // child
        while(1)
        {
            printf("我是一个子进程， pid: %d, ppid: %d\n", getpid(), getppid());
            sleep(1);
        }
    }
    else
    {
        // father
        int cnt = 5;
        while(cnt)
        {
            printf("我是一个父进程， pid: %d, ppid: %d\n", getpid(), getppid());
            cnt--;
            sleep(1);
        }
    }

    return 0;
}

还是使用刚才的ps指令进行查看

运行结果：

  • 0-5秒：父子进程并发运行，输出各自PID和PPID。子进程PPID为父进程PID（如609390）。
  • 5秒后：父进程退出，子进程PPID变为1（init）。
  • 后续：子进程无限运行，PPID始终为1。

注意：子进程从S+变为S，说明子进程从前台进程变为后台进程，CTRL + C只能杀掉前台进程，后台进程是杀不掉的，至于原因需要在后面讲解了信号才能理解，但是这里可以使用kill -9 [pid]来进行终止

三、孤儿进程与僵尸进程的对比及实际影响

为全面理解，对比两种进程的差异和实际影响：

(1) 核心区别
特性 孤儿进程 僵尸进程
定义 父进程先退出，子进程仍在运行 子进程终止，父进程未回收
进程状态 运行中（R/S） 终止（Z）
父进程 init/systemd（PID=1） 原父进程（仍存活）
资源占用 正常消耗CPU/内存 仅占用PCB（无CPU/内存消耗）
回收机制 init自动回收 需父进程手动wait或杀死父进程
危害 无 累积导致进程表溢出
(2) 实际影响
  • 孤儿进程无害：因init及时回收，无资源泄漏风险，系统设计已完美处理此场景。
  • 僵尸进程需警惕 ：若父进程不调用wait()，僵尸进程累积可能使系统无法创建新进程（需kill -9 父进程强制回收）。
  • 性能开销：init的监控和回收操作由内核高效处理，对系统性能影响可忽略。

最佳实践 ：在开发中，父进程应通过waitpid(pid, &status, WNOHANG)非阻塞回收子进程，避免孤儿进程产生（尽管无害）。若需父进程提前退出，无需额外处理，依赖init机制即可。

四、孤儿进程的处理机制：init/systemd的收养与回收

Linux通过 init进程（PID=1） 或 systemd进程（现代发行版） 自动收养孤儿进程，并负责其资源回收。具体流程如下：

(1) 收养阶段
  • PPID重置：父进程退出后，内核将子进程的PPID强制设为1（init/systemd的PID），使其成为init/systemd的子进程。
  • 收养速度：此过程是瞬时的（微秒级），用户几乎无法察觉。
(2) 回收阶段
  • init/systemd主动回收 ：init/systemd作为所有进程的祖先进程，会定期调用wait()系统调用，检查被收养的子进程是否终止：
    • 若子进程已终止（如调用exit或崩溃），init立即回收其PCB资源，释放进程ID。
    • 若子进程仍在运行（如代码中的while(1)），init会持续监控直至其终止。
  • 回收的可靠性：init/systemd被设计为永不终止，因此孤儿进程的资源回收是100%保证的，不会长期滞留。
(3) 为什么需要此机制？
  • 避免资源泄漏：孤儿进程若未被收养，退出后无人回收PCB → 僵尸进程累积 → 进程表溢出。
  • 信息传递保障 ：子进程退出码（如return 0）需传递给父进程。init作为代理，确保信息不丢失（例如Shell通过$?获取命令退出状态）。

类比解释：孤儿进程如同失去父母的孩子，被社会福利机构（init）收养。机构确保孩子成年后（进程终止）妥善处理遗产（资源回收），避免流落街头（僵尸状态）。

II. 进程优先级

1. 优先级的基本概念

  1. 优先级是什么？

    • 进程优先级（Priority）是操作系统分配 CPU 资源的先后顺序，数值越小表示优先级越高，进程越早被执行 。
    • 类比示例：类似于医院急诊科的分诊制度------危重病人（高优先级进程）优先救治，轻症患者（低优先级进程）需等待。

  2. 为什么要有优先级？

    • 资源竞争性：CPU 核心有限（甚至单核），而进程数量众多，优先级确保关键任务（如系统服务）优先获取资源，避免低效的"平等竞争" 。
    • 优化性能 ：
      • 将非关键进程（如后台日志备份）分配到特定 CPU 核心，避免干扰核心服务 。
      • 高优先级进程可快速响应（如用户交互操作），提升系统流畅度 。

  3. 优先级 vs 权限

    • 权限（Permission） ：决定进程能否访问资源（如文件、设备），属于安全性控制。
    • 优先级（Priority） ：决定进程何时获得资源，属于效率优化机制。两者无直接关联 。
    • 示例：普通用户可启动高优先级进程（需权限允许），但无法调整负 NI 值（需 root 权限） 。

2. 优先级的核心参数：PRI 与 NI

  1. PRI（Priority）

    • 进程的基础优先级，由内核动态维护，值范围一般为 60--99 （不同系统可能不同），值越小优先级越高 。
    • 注意：用户无法直接修改 PRI，只能通过调整 NI 间接影响 。

  2. NI（Nice）

    • 进程优先级的修正值，范围 -20 至 19，共 40 个级别 。

    • 作用公式 ：PRI(new) = PRI(base``) + NI

      • NI 为负 → PRI 降低 → 优先级升高（如 NI=-19 时最快执行）
      • NI 为正 → PRI 升高 → 优先级降低（如 NI=19 时最慢执行）
      • PRI(base)：Linux默认为80

    • 权限限制 ：

      • 普通用户仅能调高 NI 值（0~19），降低 NI（提升优先级）需 root 权限 。
      • 示例 ：普通用户运行 nice -n 10 vim（降低优先级），但 nice -n -5 vim 会因权限不足失败 。

3. 查看与调整优先级

1. 查看进程优先级

  • 命令 ps -l：
bash 复制代码 
ltx@hcss-ecs-d90d:~$ ps -l
F S   UID     PID    PPID  C PRI  NI ADDR SZ WCHAN  TTY          TIME CMD
0 S  1000  608742  608741  0  80   0 -  2197 do_wai pts/1    00:00:00 bash
0 R  1000  615270  608742  0  80   0 -  2518 -      pts/1    00:00:00 ps

  • 关键列：

    • PRI：实际优先级（80）

    • NI：谦让值（0）

    • CMD：进程名（ps）

2. 调整优先级

  • 启动时指定 NI（适用于新进程）：

    bash 复制代码 
    nice -n -10 /path/to/program  # 以 NI=-10 启动程序

  • 修改运行中进程：

    • renice 命令：

      bash 复制代码 
      renice -n -5 1234  # 将 PID=1234 的进程 NI 设为 -5

    • top 交互调整：

      1. 运行 top
      2. 按 r → 输入目标 PID → 输入新 NI 值 。
bash 复制代码 
$ top

bash 复制代码 
# 进入交互模式后：
r → 输入PID:  → 输入NI值:

4. 关键概念扩展

  1. 竞争性（Competition）

    • 进程竞争 CPU 资源，优先级解决"谁先执行"问题。
    • 示例：CPU 如单一收银台，优先级决定顾客（进程）排队顺序 。

  2. 独立性（Isolation）

    • 进程资源（内存、文件）独立，互不干扰。
    • 示例：浏览器崩溃不影响终端进程，因各自资源隔离 。

  3. 并行（Parallelism） vs 并发（Concurrency）

    • 并行 ：多进程在 多个 CPU 核心 同时执行（真同步）。
    • 并发 ：单 CPU 核心通过快速切换进程 模拟同时执行（伪同步） 。
    • 类比 ：
      • 并行 → 多条车道同时通车（多核 CPU）。
      • 并发 → 单车道交替放行车辆（单核 CPU 分时调度） 。

5. 为什么 NI 范围是 -20~19？

  • 历史设计：早期 Unix 系统限定该范围，Linux 延续传统 。
  • 平衡性 ：
    • 过大的负 NI（如 -30）会导致低优先级进程"饥饿"（长期得不到执行）。
    • 过大的正 NI（如 30）可能使关键进程延迟 。
  • 权限分级：限制普通用户过度提升优先级，保障系统稳定性 。

6. 动态调整的意义

  • 场景示例 ：

    1. 突发高负载 ：将视频渲染进程 NI=15（低优先级），确保 SSH 会话（NI=-10）流畅操作 。
    2. 实时任务 ：工业控制进程需 NI=-20，抢占 CPU 处理传感器数据 。

  • 系统函数支持 ：

    cpp 复制代码 
    #include <sys/resource.h>
setpriority(PRIO_PROCESS, pid, -10);  // 编程调整 NI 值 [[1]]

总结

Linux 进程优先级通过 PRI/NI 机制实现资源竞争的高效管理：

  1. 核心逻辑 ：PRI(new) = PRI(base) + NI，NI 负值提升优先级。
  2. 操作方式 ：nice、renice、top 动态调整，受权限约束。
  3. 设计目标 ：在资源有限（竞争性）和多任务（并发/并行）环境下，通过优先级优化系统响应与吞吐量。
    最终效果：让"急诊病人"优先救治，"常规检查"排队等候，最大化系统效率 。
相关推荐
胡耀超1 小时前
Umi-OCR 的 Docker安装（win制作镜像，Linux（Ubuntu Server 22.04）离线部署）
linux·深度学习·ubuntu·docker·容器·nlp·ocr
诗人不说梦^1 小时前
[BUUCTF 2018]Online Tool
linux·运维·服务器
wa的一声哭了1 小时前
python基础知识pip配置pip.conf文件
java·服务器·开发语言·python·pip·risc-v·os
别枫了1 小时前
TCP的连接
服务器·网络·tcp/ip
晚风_END3 小时前
Linux|服务器|二进制部署nacos（不是集群，单实例）（2025了，不允许还有人不会部署nacos）
linux·运维·服务器·数据库·编辑器·个人开发
白毛大侠3 小时前
在 Ubuntu 24.04 中安装 Python 2.7、pip 及 mysqlclient==1.4.6 的完整指南
python·ubuntu·pip
阿沁QWQ3 小时前
应用层协议和JSON的使用
运维·服务器·网络
运维开发王义杰3 小时前
不止于监控：深入剖析OpenTelemetry的可观察性生态体系
运维
LCG元3 小时前
基于MCP的CI/CD流水线：自动化部署到云平台的实践
运维·ci/cd·自动化
I'mSQL3 小时前
C#与FX5U进行Socket通信
运维·服务器·自动化·wpf
热门推荐
01全球最强模型Grok4，国内已可免费使用！（附教程）02KGG转MP3工具|非KGM文件|解密音频03Coze扣子平台完整体验和实践（附国内和国际版对比）04身弱武修法：玄之又玄，奇妙之门05集群聊天服务器---MySQL数据库的建立06扣子（coze）实战|我用扣子搭建了一个自动分析小红薯笔记内容的AI应用|详细步骤拆解07浅谈几种js设计模式08使用Ruby接入实时行情API教程09DeepSeek各版本说明与优缺点分析10基于odoo17的设计模式详解---单例模式