重头开始嵌入式第二十二天（Linux系统编程进程）

进程

1.进程的概念

2.PCB（process control block）

3.进程和程序有什么区别？

4.进程的内存分布

5.进程的分类

守护进程

6.进程的作用

7.进程的状态

8.进程的调度

9.查询进程的相关指令

1.ps aux

2.top

3.kill和killall

10.进程相关函数

1.fork*

2.getpid

3.getppid

11.父子进程的关系

12.进程终止的几种情况

13.进程的退出

1.僵尸进程

2.孤儿进程

3.退出函数

1.exit*

2._exit

3.atexit

1.进程的概念

进程是操作系统中的一个重要概念。

进程是指一个具有一定独立功能的程序在一个数据集合上的一次动态执行过程。

进程包含了程序执行所需的各种资源，如内存空间、CPU 时间、打开的文件、I/O 设备等。

它具有动态性，即进程是程序的执行过程，会因各种条件而产生状态的变化，如创建、就绪、运行、阻塞、终止等。

进程还具有并发性，在多道程序环境下，多个进程可以并发执行。

独立性，进程是系统进行资源分配和调度的基本单位。

每个进程都有自己独立的地址空间和上下文环境，使得不同进程之间相互隔离，互不干扰，保证了系统的稳定性和安全性。

总之，进程是操作系统进行资源管理和任务调度的核心概念之一。

2.PCB（process control block）

是一个结构体，在Linux系统中叫task_struct

常用内容包括：

在 Linux 中，进程控制块（PCB，Process Control Block）通常被称为“task_struct”结构体。其包含了众多的成员来描述进程的各种信息，以下是一些主要的成员：

1.  pid_t pid ：进程标识符（PID）。
2.  long state ：进程状态，如运行态（TASK_RUNNING）、睡眠态（TASK_INTERRUPTIBLE、TASK_UNINTERRUPTIBLE）等。
3.  void *stack ：进程的栈指针。
4.  struct mm_struct *mm ：内存管理相关的信息。
5.  struct fs_struct *fs ：文件系统相关的信息。
6.  struct files_struct *files ：打开文件的描述符表。
7.  struct signal_struct *signal ：信号处理相关的信息。
8.  struct task_struct *parent ：指向父进程的指针。
9.  struct list_head children ：子进程链表。

这只是“task_struct”结构体中的一部分成员，实际上它包含了非常丰富和详细的进程相关信息，以实现对进程的全面管理和控制。

还包括当前工作路径，umask，进程打开的文件列表，用户id，组id，进程资源上限等等

3.进程和程序有什么区别？

进程和程序是操作系统中的两个重要概念，它们有以下区别：

1. 定义不同：

- 程序是一组指令的有序集合，是静态的，存放在某种存储介质上，如硬盘。

- 进程是程序在某个数据集合上的一次执行过程，是动态的。

2. 组成不同：

- 程序仅仅是指令和数据的集合。

- 进程除了包含程序中的指令和数据，还包括程序计数器、进程堆栈、进程控制块等。

3. 存在方式不同：

- 程序可以长期存储，只要不被删除。

- 进程有其生命周期，创建后运行，运行结束后消亡。

4. 资源分配不同：

- 程序本身不占用系统资源。

- 进程在运行过程中需要分配和使用系统资源，如 CPU 时间、内存空间等。

5. 并发性不同：

- 程序不能并发执行。

- 多个进程可以在同一时间间隔内并发执行。

1）程序是永存，进程是暂时的
2）进程有程序状态的变化，程序没有
3）进程可以并发，程序无并发
4）进程与进程会存在竞争计算机的资源
5）一个程序可以运行多次，变成多个进程
一个进程可以运行一个或多个程序

总之程序是进程的静态文本，而进程是程序的动态执行。

4.进程的内存分布

在 Linux 系统中，内存分布大致如下：

1. 内核空间：位于高地址区域，通常从 0xC0000000 开始。这部分内存供内核使用，用于系统内核代码、内核数据结构、内核模块等。

2. 用户空间：位于低地址区域。

- 代码段：包含程序的机器指令。

- 数据段：包括已初始化的全局变量、静态变量等。

- BSS 段：存放未初始化的全局变量和静态变量。

- 堆：通过 malloc 等函数动态分配的内存区域，从低地址向高地址增长。

- 栈：用于函数调用时存储局部变量、函数参数等，从高地址向低地址增长。

此外，还有一些特殊的内存区域，如共享内存区域、内存映射文件区域等，用于进程间通信和文件操作。

需要注意的是，具体的内存分布细节可能会因 Linux 内核版本、硬件架构和系统配置的不同而有所差异。

5.进程的分类

进程可以按照不同的标准进行分类，常见的分类方式包括：

1. 按照执行过程分类：

- 计算密集型进程：主要进行大量的计算工作，较少进行 I/O 操作，如科学计算程序。

- I/O 密集型进程：频繁进行 I/O 操作，如文件处理、网络通信程序。

2. 按照运行状态分类：

- 运行态进程：正在使用 CPU 执行的进程。

- 就绪态进程：具备运行条件，等待被分配 CPU 资源的进程。

- 阻塞态进程：因等待某一事件（如 I/O 操作完成、资源获取等）而暂时无法运行的进程。

3. 按照优先级分类：

- 高优先级进程：具有较高的调度优先级，会优先获得 CPU 资源。

- 低优先级进程：调度优先级相对较低。

4. 按照系统和用户进程分类：

- 系统进程：执行操作系统核心功能的进程，运行在核心态。

- 用户进程：执行用户程序的进程，运行在用户态。

5. 按照交互性分类：

- 交互式进程：需要与用户进行交互，对响应时间要求较高，如命令行界面程序。

- 批处理进程：无需与用户交互，按照预定的顺序依次执行，如后台批处理任务。

不同的分类方式有助于操作系统更有效地管理和调度进程，以提高系统的性能和资源利用率。

守护进程

守护进程（Daemon Process）是在后台运行且不受终端控制的进程，通常在系统启动时自动启动，并一直运行直到系统关闭。

守护进程的主要特点包括：

1. 一直在后台运行，不与终端进行交互。

2. 通常独立于控制终端，不会因为用户注销或终端关闭而停止。

3. 负责执行一些系统级的任务，如日志记录、系统监控、服务提供等。

常见的守护进程有系统日志守护进程（syslogd）、Web 服务器守护进程（如 Apache 的 httpd）、打印守护进程（cupsd）等。

守护进程对于保证系统的正常运行和提供各种服务起着至关重要的作用。

6.进程的作用

进程在操作系统中具有以下重要作用：

1. 资源分配和管理：进程是操作系统分配资源（如 CPU 时间、内存、I/O 设备等）的基本单位。通过为每个进程分配和管理资源，操作系统可以确保资源的合理利用和公平分配。

2. 程序执行的载体：使程序能够得以运行和执行。进程为程序提供了运行时的环境和上下文，包括内存空间、寄存器状态、程序计数器等。

3. 提高系统并发性：通过并发执行多个进程，操作系统可以同时处理多个任务，从而提高系统的整体效率和响应能力，充分利用系统资源。

4. 隔离和保护：每个进程都有自己独立的地址空间和资源，这有助于防止一个进程的错误或恶意行为影响到其他进程，保障了系统的稳定性和安全性。

5. 实现系统服务：如网络服务、文件服务、打印服务等，通常都是以守护进程的形式在后台运行，为用户和其他程序提供服务。

6. 支持多用户和多任务环境：使得多个用户可以同时运行各自的程序，互不干扰。

7. 动态适应系统负载：根据系统的负载情况，进程可以被创建、暂停、恢复或终止，以优化系统性能。

总之，进程是操作系统实现多任务、资源管理、系统服务和稳定性的关键概念和机制。

7.进程的状态

在 Linux 中，进程主要有以下几种状态：

1. R (TASK_RUNNING) ：运行态或就绪态。表示进程要么正在运行，要么准备运行，正在等待被调度到 CPU 上执行。

2. S (TASK_INTERRUPTIBLE) ：可中断的睡眠态。进程正在等待某个事件（如资源、信号等），处于睡眠状态，但可以被信号唤醒。

3. D (TASK_UNINTERRUPTIBLE) ：不可中断的睡眠态。进程也在等待某个事件，处于睡眠状态，但不能被信号唤醒，通常是在等待一些硬件条件。

4. T (TASK_STOPPED) ：暂停态。进程被暂停，例如通过发送 SIGSTOP 等信号。

5. Z (TASK_DEAD - EXIT_ZOMBIE) ：僵尸态。进程已经结束，但其资源还未被父进程回收。

6. X (TASK_DEAD - EXIT_DEAD) ：已死亡态。进程完全终止，资源已被回收。

8.进程的调度

进程调度是操作系统的核心功能之一，用于决定哪个进程在何时获得 CPU 资源进行执行。

在 Linux 中，常见的进程调度策略包括：

1. 先来先服务（FCFS）：按照进程到达就绪队列的先后顺序分配 CPU。这种策略简单，但可能导致短作业等待时间过长。

2. 短作业优先（SJF）：优先选择预计运行时间短的进程执行。然而，准确预测进程的运行时间往往比较困难。

3. 时间片轮转（RR）：将 CPU 时间划分为固定大小的时间片，每个进程轮流获得一个时间片进行执行。如果时间片用完，进程还未完成，则回到就绪队列末尾等待下一轮调度。

4. 优先级调度：为每个进程赋予一个优先级，优先级高的进程优先获得 CPU 资源。

Linux 内核的调度器会综合考虑进程的优先级、等待时间、剩余运行时间等因素来进行调度决策，以实现系统的高效运行和资源的合理分配。

进程调度的时机通常包括：

1. 进程主动放弃 CPU，如等待 I/O 操作完成、执行系统调用等。

2. 时间片用完。

3. 新进程创建或现有进程从阻塞态转为就绪态。

进程调度的目标是在保证系统公平性的前提下，提高系统的整体性能和响应速度。

总的来说，就是宏观并行，微观串行

9.查询进程的相关指令

1.ps aux

“ps”是 Linux 系统中用于查看进程状态的命令。

“ps”命令有多种选项和参数，常见的用法包括：

“ps -ef”：以全格式显示系统中所有进程的详细信息，包括进程 ID（PID）、父进程 ID（PPID）、CPU 使用率、内存使用情况等。

“ps aux”：显示系统中所有用户的进程信息，包括进程的所有者、CPU 使用率、内存使用情况等。

通过使用“ps”命令及其不同的选项，可以获取有关系统中正在运行的进程的各种信息，以便进行进程管理、性能监控和故障排查等操作。

2.top

“top”命令是 Linux 系统中用于实时动态地查看系统进程运行状态和系统资源使用情况的工具。

当执行“top”命令后，会显示以下主要信息：

1. 系统概要：包括当前时间、系统运行时间、登录用户数、系统负载等。

2. 进程列表：按 CPU 使用率等指标降序排列，显示每个进程的 PID、用户、CPU 使用率、内存使用率、运行时间等详细信息。

3. 系统资源使用情况：如 CPU 使用率（按多核分别显示）、内存使用量、交换分区使用量等。

通过“top”命令，可以实时监控系统性能，及时发现资源占用过高的进程，并采取相应的措施进行优化或处理。

3.kill和killall

在 Linux 中，“kill”和“killall”都是用于向进程发送信号以控制其行为的命令，但它们在使用方式和功能上有一些区别。

“kill”命令通过指定进程的 PID（进程标识符）来向单个进程发送信号。基本语法是： kill [信号选项] 进程 ID 。

“killall”命令则是通过进程名称来向多个同名进程发送信号。基本语法是： killall [信号选项] 进程名称。

例如，如果要终止名为“myprocess”的所有进程，可以使用“killall myprocess”；如果要向名为“myprocess”的进程发送特定信号（如“SIGTERM”），可以使用“killall -TERM myprocess”。

需要注意的是，使用这两个命令时要谨慎，确保了解所发送信号的影响，以免意外终止重要的系统进程导致系统不稳定或数据丢失。

在 killall 命令中，常用的信号选项与 kill 命令类似，以下是一些常见的信号选项：

1. -1 或 -HUP ：挂起信号，通常用于通知进程重新读取配置文件。

2. -2 或 -INT ：中断信号，类似于在终端按下 Ctrl + C 。

3. -9 或 -KILL ：强制终止信号，进程无法捕获和处理。

4. -15 或 -TERM ：默认的终止信号，进程可以自行处理终止操作。

可以根据具体的需求选择合适的信号选项来控制进程的行为。但请注意，使用强制终止信号（如 -9 ）可能会导致进程无法正常清理资源，应谨慎使用。

10.进程相关函数

1.fork*

在 Linux 中， fork 函数用于创建一个新的进程。

fork 函数调用后会返回两次，在父进程中返回子进程的 PID（进程标识符），在子进程中返回 0 。

以下是一个简单的 C 语言示例，展示了 fork 函数的使用：

#include <stdio.h>

#include <unistd.h>



int main() {

    pid_t pid = fork();



    if (pid == 0) {

        // 子进程执行的代码

        printf("I'm the child process!\n");

    } else if (pid > 0) {

        // 父进程执行的代码

        printf("I'm the parent process. Child PID is %d\n", pid);

    } else {

        // fork 失败的处理

        perror("Fork failed");

        return 1;

    }



    return 0;

}

通过 fork 函数创建的子进程会继承父进程的许多属性，如打开的文件描述符、环境变量等，但子进程有自己独立的地址空间。

2.getpid

在 Linux 系统中， getpid 函数用于获取当前进程的进程标识符（PID）。

以下是一个使用 getpid 函数的 C 语言示例代码：

#include <stdio.h>

#include <unistd.h>



int main() {

    pid_t pid = getpid();

    printf("当前进程的 PID 是: %d\n", pid);

    return 0;

}

getpid 函数通常在需要获取当前进程标识以便进行进程间通信、资源管理或日志记录等操作时使用。

3.getppid

在 Linux 系统中， getppid 函数用于获取当前进程的父进程标识符（PPID）。

以下是一个使用 getppid 函数的 C 语言示例代码：

#include <stdio.h>

#include <unistd.h>



int main() {

    pid_t ppid = getppid();

    printf("当前进程的父进程 PID 是: %d\n", ppid);

    return 0;

}

通过 getppid 函数获取到的父进程标识符，可以用于了解进程之间的关系和进行相关的进程管理操作。

11.父子进程的关系

父子进程之间存在以下关系和特点：

1. 资源继承：子进程会继承父进程的部分资源和属性，例如打开的文件描述符、环境变量、当前工作目录等。但子进程有自己独立的地址空间，对内存的修改不会影响到父进程。
2. 执行顺序：父子进程的执行顺序是不确定的，由操作系统的调度器决定。
3. 进程标识：子进程有自己唯一的进程标识符（PID），而父进程可以通过 fork 函数的返回值或 getpid 、 getppid 函数获取子进程和自身的 PID 及父进程的 PID。
4. 通信方式：父子进程可以通过一些进程间通信（IPC）机制进行通信，如管道、消息队列、共享内存等。
5. 终止影响：父进程终止时，子进程不一定会终止，除非父进程是子进程的唯一控制者。但子进程终止时，父进程需要通过某种方式（如 wait 系列函数）来获取子进程的终止状态，否则子进程可能成为僵尸进程。
6. 权限继承：子进程通常继承父进程的权限和访问控制属性。

总之，父子进程之间既有联系又相互独立，这种关系为多进程编程提供了灵活和强大的控制方式。

12.进程终止的几种情况

在 Linux 中，进程终止常见的情况主要有以下几种：

1. 从主函数返回：即执行完 main 函数中的所有代码，正常结束进程。main 中return.

2. 调用 exit 函数：可以指定进程的退出状态码。c库函数，会执行io库的清理工作，关闭所有的流，以及所有打开的文件。已经清理函数（atexit）。

3. 调用 _exit 或 _Exit 函数：立即终止进程，不进行缓冲区刷新等清理操作。

4. 接收到信号：例如接收到无法处理或默认处理为终止进程的信号，如 SIGKILL （9 号信号，无法被捕获、阻塞或忽略）和 SIGTERM （15 号信号，默认动作是终止进程，进程可以捕获并处理它）。signal kill pid.

5. 程序出现严重错误：如段错误（Segmentation Fault）、总线错误（Bus Error）等。abort()

6. 资源耗尽：包括内存、文件描述符等资源耗尽，导致无法继续运行。

7. 父进程终止：某些情况下，如果父进程终止，子进程可能也会受到影响而终止。

8. 系统关机或重启：所有进程都会被终止。

9.主线程退出,

10.最后一个线程被pthread_cancle

11.主线程调用pthread_exit

13.进程的退出

1.僵尸进程

在 Linux 中，僵尸进程（Zombie Process）是指已经完成执行但尚未被其父进程回收资源的进程。

当一个子进程结束时，它的内核资源（如进程控制块 PCB 等）并不会立即被释放，而是会保留一些信息（如进程的退出状态），以便父进程能够获取到子进程的结束状态。如果父进程没有及时调用相关函数（如 wait 或 waitpid ）来获取这些信息并回收子进程的资源，那么子进程就会成为僵尸进程。

僵尸进程会占用一定的系统资源（主要是进程表中的一个条目），虽然占用资源较少，但如果系统中存在大量的僵尸进程，可能会导致进程表被填满，从而影响系统的性能和新进程的创建。

为了避免僵尸进程的产生，父进程应该及时处理子进程的结束状态并回收其资源。

2.孤儿进程

在 Linux 中，孤儿进程是指其父进程先于子进程结束的进程。

当父进程提前终止时，子进程仍在运行。此时，子进程会被操作系统的特殊进程（通常是 init 进程，其 PID 为 1）收养，成为 init 进程的子进程。init 进程会负责监控和清理这些孤儿进程终止时的资源，所以孤儿进程通常不会导致系统资源的泄漏或其他不良影响。

3.退出函数

1.exit*

在 C 和 C++ 中， exit 函数用于终止程序的执行。

exit 函数的声明通常在 <stdlib.h> 头文件中。它接受一个整数参数作为程序的退出状态码。

以下是 exit 函数的一些特点和使用要点：

1. 立即终止程序：无论程序当前处于何种执行位置，调用 exit 都会导致程序的立即终止。

2. 资源清理：在终止程序之前， exit 会执行一些清理操作，例如刷新输出缓冲区、关闭打开的文件等，但这并不意味着它能清理所有的资源，特别是由用户手动分配的动态内存。

3. 退出状态码：通过传递给 exit 的整数参数，可以向操作系统或调用该程序的其他进程传达程序的终止状态。通常，0 表示正常结束，非零值表示异常结束或出现错误。

例如：

#include <stdio.h>

#include <stdlib.h>



int main() {

    printf("Before exit\n");

    exit(1); // 程序以退出状态码 1 终止

    printf("This will not be printed\n"); // 因为程序在 exit 调用后就终止了，所以这行不会被执行

    return 0;

}

总的来说， exit 函数提供了一种在程序的任何位置强制终止并返回状态的方式。

2._exit

在 C 语言中， _exit 函数用于直接终止进程，其声明通常在 <unistd.h> 头文件中。

与 exit 函数相比， _exit 函数的行为更加直接和“生硬”，它不会执行一些由 exit 执行的清理和缓冲刷新操作。

具体来说， _exit 函数会立即终止进程，不会刷新标准 I/O 缓冲区，也不会调用由 atexit 注册的函数和信号处理函数。

以下是一个简单的示例，展示了 _exit 的使用：

#include <stdio.h>

#include <unistd.h>



int main() {

    printf("Before _exit\n");

    _exit(0); // 直接终止进程，不会输出缓冲区中的内容

    printf("This will not be printed\n");

    return 0;

}

在上述示例中，由于使用了 _exit ，所以 “Before _exit” 不会被输出到控制台。

3.atexit

在 C 语言中， atexit 函数用于注册在程序正常终止时要调用的函数。

atexit 函数的声明在 <stdlib.h> 头文件中，其函数原型为：

int atexit(void (*function)(void));

使用 atexit 注册的函数在程序通过 exit 正常终止时（不包括通过 _exit 或从 main 函数返回），会按照注册的顺序逆序被调用。

以下是一个简单的示例：

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

void myFunction1() {
    printf("Function 1 is called at exit\n");
}

void myFunction2() {
    printf("Function 2 is called at exit\n");
}

int main() {
    atexit(myFunction1);
    atexit(myFunction2);

    printf("Main function\n");

    return 0;
}

在这个示例中，当程序正常终止时，会先调用 myFunction2 ，然后再调用 myFunction1 。