当前位置： 首页 > news >正文

【Linux系统】进程概念

news 来源：原创 2025/4/26 19:52:25

1. 冯诺依曼体系结构

我们常见的计算机，如笔记本。我们不常见的计算机，如服务器，大部分都遵守冯诺依曼体系。
在这里插入图片描述

截至目前，我们所认识的计算机，都是由一个个的硬件组件组成：

  • 输入单元：包括键盘，鼠标，扫描仪，写板等
  • 中央处理器(CPU)：含有运算器和控制器等
  • 输出单元：显示器，打印机等

关于冯诺依曼，必须强调几点：

  • 这里的存储器指的是内存
  • 不考虑缓存情况，这里的CPU能且只能对内存进行读写，不能访问外设(输入或输出设备)
  • 外设(输入或输出设备)要输入或者输出数据，也只能写入内存或者从内存中读取。
  • 所有设备都只能直接和内存打交道。

2. 操作系统(Operator System)

2-1 概念

任何计算机系统都包含一个基本的程序集合，称为操作系统(OS)。笼统的理解，操作系统包括：

  • 内核（进程管理，内存管理，文件管理，驱动管理）
  • 其他程序（例如函数库，shell程序等等）
    在这里插入图片描述

2-2 设计OS的目的

  • 对下，与硬件交互，管理所有的软硬件资源
  • 对上，为用户程序（应用程序）提供一个良好的执行环境
    在这里插入图片描述

2-3 核心功能

在整个计算机软硬件架构中，操作系统的定位是：一款纯正的“搞管理”的软件

计算机管理硬件

  1. 描述起来，用struct结构体
  2. 组织起来，用链表或其他高效的数据结构

先描述再组织

2-5 系统调用和库函数概念

  • 在开发角度，操作系统对外会表现为一个整体，但是会暴露自己的部分接口，供上层开发使用，这部分由操作系统提供的接口，叫做系统调用。
  • 系统调用在使用上，功能比较基础，对用户的要求相对也比较高，所以，有心的开发者可以对部分系统调用进行适度封装，从而形成成库，有了库，就“很有利于上层用户”或者“开发者”进行二次开发。

3. 进程

3-1 基本概念与基本操作

3-1-1 基本概念
  • 课本概念：程序的一个执行实例，正在执行的程序等
  • 内核观点：担当分配系统资源（CPU时间，内存）等实体。
3-1-2 描述进程-PCB

进程信息被放在一个叫做进程控制块（process control block）结构中，Linux操作系统下的PCB是task_struct 。task_struct是Linux内核的一种数据结构，它会被装载到RAM(内存)里并且包含着进程的信息。

3-1-3 task_struct内容分类

标示符: 描述本进程的唯一标示符，用来区别其他进程。

  • 状态: 任务状态，退出代码，退出信号等。
  • 优先级: 相对于其他进程的优先级。
  • 程序计数器: 程序中即将被执行的下一条指令的地址。
  • 内存指针: 包括程序代码和进程相关数据的指针，还有和其他进程共享的内存块的指针
  • 上下文数据: 进程执行时处理器的寄存器中的数据（休学例子，要进程CPU，寄存器数据）
  • I/O状态信息: 包括显示的I/O请求,分配给进程的I/O设备和被进程使用的文件列表。
  • 记账信息: 可能包括处理器时间总和，使用的时钟数总和，时间限制，记账号码等。
  • 组织具体详细信息后续会介绍

可以在内核源代码里找到它。所有运行在系统里的进程都以task_struct链表的形式存在内核里。

3-1-4 查看进程

  • 进程的信息可以通过 /proc 系统文件夹查看
    如：要获取PID为1的进程信息，你需要查看 /proc/1 这个文件夹。
    在这里插入图片描述

  • 大多数进程信息同样可以使用top和ps这些用户级工具来获取
    在这里插入图片描述

3-1-5 通过系统调用获取进程标示符
  • 进程id (PID)
  • 父进程id (PPID)
  • 在linux系统中，进程启动之后新建任何进程的时候，都是由自己的父进程创建的！
#include <stdio.h>
#include <sys/types.h>
#include <unistd.h>

int main()
{
    printf("pid: %d\n", getpid());
    printf("ppid: %d\n", getppid());
    return 0;
}

在这里插入图片描述
这里可以注意到ppid是一直保持不变的。

3-1-6 fork初识
功能概述

fork 函数的主要功能是创建一个新进程，该新进程被称作子进程，而调用 fork 函数的进程则是父进程。子进程基本是父进程的副本，会复制父进程的大部分内容，像内存空间、文件描述符等。

函数原型
#include <unistd.h>

pid_t fork(void);
返回值
  • 负值：当 fork 调用失败时，会返回 -1，并且会设置 errno 来表明错误原因。常见的错误原因包含系统资源不足等。
  • 零：如果返回值是 0，那就意味着当前代码正在子进程里执行。
  • 正值：要是返回值为正，表明当前代码处于父进程中，这个正值就是新创建子进程的进程 ID（PID）。
代码示例
#include <stdio.h>
#include <unistd.h>

int main() {
    pid_t pid;

    pid = fork();

    if (pid < 0) {
        // 处理错误
        perror("fork");
        return 1;
    } else if (pid == 0) {
        // 子进程
        printf("子进程: 我的 PID 是 %d，我的父进程 PID 是 %d\n", getpid(), getppid());
    } else {
        // 父进程
        printf("父进程: 我的 PID 是 %d，我创建的子进程 PID 是 %d\n", getpid(), pid);
    }

    return 0;
}
执行流程
  1. 父进程调用 fork 函数。
  2. 系统会为子进程分配必要的资源，复制父进程的大部分内容。
  3. 父进程和子进程会从 fork 函数调用之后的代码处开始继续执行，不过它们的 fork 返回值不同。
  4. 父进程和子进程是并发执行的，它们的执行顺序无法提前确定，这取决于操作系统的调度算法。
重点
  • fork有两个返回值
  • 父子进程代码共享，数据各自开辟空间，私有一份（采用写时拷贝）
  • fork之后通常要用if进行分流
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>

int count = 0;

int main()
{
    pid_t pid;

    pid = fork();

    if (pid < 0)
    {
        // 处理错误
        perror("fork");
        return 1;
    }
    else if (pid == 0)
    {
        // 子进程
        while (1)
        {
            printf("子进程: 我的 PID 是 %d，我的父进程 PID 是 %d,count:%d\n", getpid(), getppid(), count);
            sleep(1);
        }
        printf("子进程: 我的 PID 是 %d，我的父进程 PID 是 %d\n", getpid(), getppid());
    }
    else
    {
        // 父进程
        while (1)
        {
            count++;
            printf("父进程: 我的 PID 是 %d，我的父进程 PID 是 %d,count:%d\n", getpid(), pid, count);
            sleep(1);
        }
    }

    return 0;
}

在这里插入图片描述

  1. fork为什么会有两个返回值？

fork 函数设计为有两个返回值，主要是为了让父进程和子进程能够区分彼此，并在后续执行不同的操作逻辑。因为在 fork 之后，父进程和子进程会并发执行相同的代码段，需要一种机制来区分当前执行的是父进程还是子进程，以便根据不同的角色执行不同的任务。

  1. 两个返回值各自如何返回？
  • 父进程：内核会将新创建的子进程的进程 ID（PID）作为 fork 函数的返回值返回给父进程。因为父进程可能需要管理多个子进程，通过子进程的 PID，父进程可以方便地对子进程进行操作，如等待子进程结束（使用 wait 或 waitpid 函数）、向子进程发送信号等。
  • 子进程：内核会将 0 作为 fork 函数的返回值返回给子进程。这是因为子进程通常不需要知道自己的 PID（可以通过 getpid 函数获取），而 0 可以作为一个明确的标识，让子进程知道自己是子进程身份，从而执行相应的代码逻辑。

3-2 进程状态

3-2-1 Linux内核源代码

为了弄明白正在运行的进程是什么意思，我们需要知道进程的不同状态。一个进程可以有几个状态（在Linux内核里，进程有时候也叫做任务 ）。
下面的状态在kernel源代码里定义：

/*
 *The task state array is a strange "bitmap" of
 *reasons to sleep. Thus "running" is zero, and
 *you can test for combinations of others with
 *simple bit tests.
 */
static const char *const task_state_array[] = {
    "R (running)", /*0 */
    "S (sleeping)", /*1 */
    "D (disk sleep)", /*4 */
    "T (stopped)", /*8 */
    "t (tracing stop)", /*8 */
    "X (dead)", /*16 */
    "Z (zombie)", /*32 */
};
  • R运行状态（running）：并不意味着进程一定在运行中，它表明进程要么是在运行中要么在运行队列里。
  • S睡眠状态（sleeping）：意味着进程在等待事件完成（这里的睡眠有时候也叫做可中断睡眠（interruptible sleep） ）。
  • D磁盘休眠状态（Disk ）：有时候也叫不可中断睡眠状态（uninterruptible sleep） ，在这个状态的进程通常会等待IO的结束。
  • T停止状态（stopped）：可以通过发送SIGSTOP信号给进程来停止（T）进程。这个被暂停的进程可以通过发送SIGCONT信号让进程返回运行状态。
  • X死亡状态（dead）：这个状态只是一个返回状态，你不会在任务列表里看到这个状态。
    在这里插入图片描述
3-2-2 进程状态查看

ps aux / ps axj 命令

  • a：显示一个终端所有的进程，包括其他用户的进程。
  • x：显示没有控制终端的进程，例如后台运行的守护进程。
  • j：显示进程归属的进程组ID、会话ID、进程ID，以及与作业控制相关的信息。
  • u：以用户为中心的格式显示进程信息，提供进程的详细信息，如用户、CPU和内存使用情况等 。
3-2-3 Z(zombie)-僵尸进程

僵尸状态（Zombies）是一个比较特殊的状态。当进程退出并且父进程（使用wait()系统调用）没有读取子进程退出的返回代码时就会产生僵尸（Z）进程 。

  • 僵死进程会以终止状态保持在进程表中，但会一直在等待父进程读取退出状态代码。
  • 所以，只要子进程退出，父进程还在运行，但父进程没有读取子进程状态，子进程进入Z状态 。

来一个创建维持30秒的僵死进程例子：

#include <stdio.h>
#include <stdlib.h>

int main()
{
    pid_t id = fork();

    if(id < 0){
        perror("fork");
        return 1;
    }
    else if(id > 0){ //parent
        printf("parent[%d] is sleeping...\n", getpid());
        sleep(30);
    }
    else{
        printf("child[%d] is begin Z...\n", getpid());
        sleep(5);
        exit(EXIT_SUCCESS);
    }
    return 0;
}

编译并在另一个终端下启动监控

# 示例监控命令
while :; do ps aux | grep test | grep -v grep; sleep 1; echo "################"; done

看到结果
在这里插入图片描述

3-2-4 僵尸进程危害
  • 进程的退出状态必须被维持下去，因为他要告诉关心它的进程（父进程），你交给我的任务，我办的怎么样了。而父进程如果一直不读取，那子进程就一直处于Z状态？是的！
  • 维护退出状态本身就是要用数据维护，也属于进程基本的信息，所以保存在task_struct(PCB)中， 那句话说，Z状态一直不退出，PCB一直都要维护？是的！
  • 据那个对象创建了很多子进程，就是不回收，是不**是就会造成内存资源的浪费？是的！**因为数据结构对象本身就要占用内存，想想C中定义一个结构体变量（对象），是要在内存的某个位置进行开辟空间！
  • 内存泄漏? 是的！
  • 如何避免？后面讲 。

至此，值得关注的进程状态全部讲解完成，下面来认识另一种进程 。

3-2-5 孤儿进程
  • 父进程如果提前退出，那么子进程后退出，进入Z之后，那该如何处理呢?
  • 父进程先退出，子进程就称之为“孤儿进程” 。
  • 孤儿进程被1号init进程领养，当然要有init进程回收喽。

示例代码：

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main()
{
    pid_t id = fork();
    if(id < 0){
        perror("fork");
        return 1;
    }
    else if(id == 0){ //child
        printf("I am child, pid : %d\n", getpid());
        sleep(5);
    }
    else{
        printf("I am parent, pid: %d\n", getpid());
        sleep(3);
        exit(0);
    }
    return 0;
}

3-3 进程优先级

3-3-1 基本概念
  • cpu资源分配的先后顺序，就是指进程的优先权（priority） 。
  • 优先权高的进程有优先执行权利。配置进程优先权对多任务环境的linux很有用，可以改善系统性能。
  • 还可以把进程运行到指定的CPU上，这样一来，把不重要的进程安排到某个CPU，可以大大改善系统整体性能。
3-3-2 查看系统进程

在linux或者unix系统中，用ps -l命令则会类似输出以下几个内容：
在这里插入图片描述

我们很容易注意到其中的几个重要信息，有下：

  • UID：代表执行者的身份
  • PID：代表这个进程的代号
  • PPID： 代表这个进程是由哪个进程发展衍生而来的，亦即父进程的代号
  • PRI： 代表这个进程可被执行的优先级，其值越小越早被执行
  • NI： 代表这个进程的nice值
3-3-3 PRI and NI
  • PRI也还是比较好理解的，即进程的优先级，或者通俗点说就是程序被CPU执行的先后顺序，此值越小进程的优先级别越高。
  • 那NI呢?就是我们所说的nice值了，其表示进程可被执行的优先级的修正数值。
  • PRI值越小越快被执行，那么加入nice值后，将会使得PRI变为：PRI(new)=PRI(old)+nice。
  • 这样，当nice值为负值的时候，那么该程序将会优先级值将变小，即其优先级会变高，则其越快被执行。
  • 所以，调整进程优先级，在Linux下，就是调整进程nice值。
  • nice其取值范围是-20至19，一共40个级别。
3-3-4 PRI vs NI
  • 需要强调一点的是，进程的nice值不是进程的优先级，他们不是一个概念，但是进程nice值会影响到进程的优先级变化。
  • 可以理解nice值是进程优先级的修正修正正数 据。
3-3-5 查看进程优先级的命令

用top命令更改已存在进程的nice：

  • top
  • 进入top后按 “r” ->输入进程PID->输入nice值

注意：

  • 其他调整优先级的命令：nice，renice
  • 系统函数
3-3-6 补充概念-竞争、独立、并行、并发
  • 竞争性：系统进程数目众多，而CPU资源只有少量，甚至1个，所以进程之间是具有竞争属性的。为了高效完成任务，更合理竞争相关资源，便具有了优先级。
  • 独立性：多进程运行，需要独享各种资源，多进程运行期间互不干扰。
  • 并行：多个进程在多个CPU下分别，同时进行运行，这称之为并行。
  • 并发：多个进程在一个CPU下采用进程切换的方式，在一段时间之内，让多个进程都得以推进，称之为并发。
  • Concurrent = Two Queues One Coffee Machine（并发 = 两条队伍 一台咖啡机）
  • Parallel = Two Queues Two Coffee Machines（并行 = 两条队伍 两台咖啡机）

3.4 进程切换

CPU上下文切换： 实际含义是任务切换，或者CPU寄存器切换。

当多任务内核决定运行另外的任务时，它保存正在运行任务的当前状态，也就是CPU寄存器中的全部内容。这些内容被保存在任务自己的堆栈中，入栈工作完成后就把下一个将要运行的任务的当前状况从该任务的栈中重新装入CPU寄存器，并开始下一个任务的运行，这一过程就是context switch。

在这里插入图片描述

参考一下Linux内核0.11代码，把进程的上下文数据放入tss_struct的结构中。

struct task_struct
{
    /* these are hardcoded - don't touch */
    long state;         /* -1 unrunnable, 0 runnable, >0 stopped */
    long counter;
    long priority;
    long signal;
    struct sigaction sigaction[32];
    long blocked;        /* bitmap of masked signals */
    /* various fields */
    int exit_code;
    unsigned long start_code, end_code, end_data, brk, start_stack;
    long pid, father, pgrp, session, leader;
    unsigned short uid, euid, suid;
    unsigned short gid, egid, sgid;
    long alarm;
    long utime, stime, cutime, cstime, start_time;
    unsigned short used_math;
    /* file system info */
    int tty;            /* -1 if no tty, so it must be signed */
    unsigned short umask;
    struct m_inode *pwd;
    struct m_inode *root;
    struct m_inode *executable;
    unsigned long close_on_exec;
    struct file *filp[NR_OPEN];
    /* ldt for this task 0 - zero 1 - cs 2 - ds&ss */
    struct desc_struct ldt[3];
    /* tss for this task */
    struct tss_struct tss;
};

// 任务状态段数据结构（参见列表后的信息）。
struct tss_struct
{
    long back_link;     /* 16 high bits zero */
    long esp0;
    long ss0;            /* 16 high bits zero */
    long esp1;
    long ss1;            /* 16 high bits zero */
    long esp2;
    long ss2;            /* 16 high bits zero */
    long cr3;
    long eip;
    long eflags;
    long eax, ecx, edx, ebx;
    long esp;
    long ebp;
    long esi;
    long edi;
    long es;            /* 16 high bits zero */
    long cs;            /* 16 high bits zero */
    long ss;            /* 16 high bits zero */
    long ds;            /* 16 high bits zero */
    long fs;            /* 16 high bits zero */
    long gs;            /* 16 high bits zero */
    long ldt;            /* 16 high bits zero */
    long trace_bitmap;  /* bits: trace 0, bitmap 16-31 */
    struct i387_struct i387;
};

注意：
时间片：当代计算机都是分时操作系统，每个进程都有它合适的时间片（其实就是一个计数器）。时间片到达，进程就被操作系统从CPU中剥离下来。

Linux2.6内核进程O(1)调度队列

在这里插入图片描述

3-4-1 一个CPU拥有一个runqueue

如果有多个CPU就要考虑进程个数的负载均衡问题 。

3-4-2 优先级
  • 普通优先级：100~139（与nice值的取值范围可对应 ）
  • 实时优先级：0~99 （不关心 ）
3-4-3 活动队列
  • 时间片还没有结束的所有进程都按照优先级放在该队列 。
  • nr_active：总共有多少个运行状态的进程 。
  • queue[140]：一个元素就是一个进程队列，相同优先级的进程按照FIFO规则进行排队调度，数组下标就是优先级 。
    • 从该结构中选择最合适进程的过程：
      1. 从0下表开始遍历queue[140] 。
      2. 找到第一个非空队列，该队列必定为优先级最高的队列 。
      3. 拿选中队列的第一个进程，开始运行，调度完成 。
      4. 遍历queue[140]时间复杂度是常数 。
  • bitmap[5]：一共140个优先级，一共140个进程队列，为了提高查找非空队列的效率，就可以用5*32个比特位表示队列是否为空，这样，便可大大提高查找效率 。
    在这里插入图片描述
3-4-4 过期队列
  • 过期队列和活动队列结构一模一样 。
  • 过期队列上放置的进程，都是时间片耗尽的进程 。
  • 当活动队列上的进程都被处理完毕之后，对过期队列的进程进行时间片重新计算 。
3-4-5 active指针和expired指针
  • active指针永远指向活动队列 。
  • expired指针永远指向过期队列 。
  • 活动队列上的进程会越来越少，过期队列上的进程会越来越多，因为进程时间片到期时一直没存在。在合适的时候，只要能够交换active指针和expired指针的内容，就相当于有了一批新的活动进程 。
3-4-6 总结

在系统当中查找一个最合适调度的进程的时间复杂度是一个常数，不随着进程增多而导致时间成本环境变量称之为进程调度O(1)算法 。

相关文章：

  • qt designer 创建窗体选择哪种屏幕大小
  • Golang｜抽奖相关
  • 路由器端口映射的意思、使用场景、及内网ip让公网访问常见问题和解决方法
  • 项目部署-(二)Linux下SpringBoot项目自动部署
  • MySQL流程控制
  • 如何管理“灰色时间”导致的成本漏洞
  • SOLID原则详解：提升软件设计质量的关键
  • 【DDR 内存学习专栏 1.3.1 -- DDR 的 Bank 及 burst 访问】
  • 空间信息可视化——WebGIS前端实例（一）
  • 基于Nacos+动态线程池的分布式系统弹性设计：投行交易与风控场景实战
  • 安当TDE透明加密技术：企业机密文件和数据库加密解决方案
  • 大数据学习栈记——Redis安装及其使用
  • MVCC是什么？MVCC的作用是什么？MVCC实现方式有哪些？
  • 批量将多个文件转成压缩包，支持批量设置压缩密码
  • CSI-external-provisioner
  • 从零开始学A2A一：A2A 协议概述与核心概念
  • 人工智能驱动的科研新范式及学科应用研究
  • 【Java学习笔记】Java初级阶段代码规范
  • 基于项目管理的轻量级目标检测自动标注系统【基于 YOLOV8】
  • 打造可控可测的星座网络：IPLOOK低轨通信仿真平台搭建实践
  • 王旭任甘肃省副省长
  • 双拥主题歌曲MV：爱我人民，爱我军
  • 11-13世纪的地中海贸易
  • 第六次“太空会师”，神舟二十号3名航天员顺利进驻中国空间站
  • 夜读丨修车与“不凑合”
  • 特朗普激发加拿大爱国热情：大选提前投票人数创纪录，魁北克分离情绪被冲淡