Linux：进程概念（二.查看进程、父进程与子进程、进程状态详解）_查询注释父进程的步骤和注意事项

Linux：进程概念（二.查看进程、父进程与子进程、进程状态详解）

上次讲了一下:Linux：冯诺依曼体系结构、操作系统、初识进程

---

---

1.查看进程

1.1准备工作

先写好代码：

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

int main()
{
    while(1)
    {
        printf("I'm a process\n");
        sleep(2)
    }//写一个死循环，没两秒打印一次
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13

makefile文件也写好：

mycode:code.c
	gcc -o $@ $^ -std=c99
.PHONY:clean
clean 
	rm -f mycode
1
2
3
4
5

1.2 指令：ps—显示当前系统中运行的进程信息

ps 是一个常用的 Unix/Linux 命令，用于显示当前系统中运行的进程信息。它的名称来源于 “process status”（进程状态）的缩写。通过 ps 命令，您可以查看正在运行的进程的各种信息，例如进程 ID、CPU 使用情况、内存占用、进程状态等。

常用的 ps 命令选项和参数：

• -e 或 -A：显示所有进程，等同于 -e。

• -f：显示全格式，包括进程的 UID、PID、PPID、C、STIME、TTY、TIME 和 CMD 等信息。

• -l：以长格式显示进程信息，包括 UID、PID、PPID、C、PRI、NI、ADDR、SZ、WCHAN、TTY、TIME 和 CMD 等。

• -u：以用户格式显示进程信息，包括 USER、PID、%CPU、%MEM、VSZ、RSS、TTY、STAT、START 和 TIME。

• -a：显示所有进程，包括其他用户的进程。

• -j：以作业格式显示进程信息，包括 PID、PPID、PGID、SID、UID、C、STIME、TTY、TIME 和 CMD 等。

• -x：同时显示没有控制终端的进程（守护进程）。

综合来说，ps -ajx 命令会列出当前系统中所有进程的详细信息，包括进程的作业信息以及其他相关信息。

常见的 ps 命令用法包括：

• ps：显示当前用户的正在运行的进程。
• ps -ajx ：ps -ajx 是一个常用的 Unix/Linux 命令，用于显示当前系统中所有进程的详细信息，并以完整的格式输出
• ps -ajx | grep process_name：查找特定进程名的进程。

在输出中，第一个进程是你的可执行文件 mycode 的进程，第二个进程是由于你使用了 grep 命令进行字符串匹配而产生的 grep 进程

具体来说：

• 第一个进程（PID为10995）是你的可执行文件 mycode，它的 PPID（Parent Process ID）是10138，表示它的父进程是PID为10138的进程。
• 第二个进程（PID为10999）是 grep 命令，它用于搜索包含字符串 “mycode” 的进程。

终止后：

1.3查看进程属性

进程的属性都在task_struct 里，而task_struct是操作系统内部的数据，我们想要访问内部的数据只能通过系统调用

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
int main()
{
    pid_t id =getpid();
    while(1)
    {
        printf("I'm a process,pid:%d\n",id);
        sleep(2);
    }//写一个死循环，没两秒打印一次
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

getgid() 函数是一个系统调用，用于获取调用进程的有效组 ID（Group ID）。在 Linux 中，每个进程都属于一个或多个组，getgid() 函数返回调用进程的有效组 ID。其函数原型定义在 <unistd.h> 头文件中：

#include <unistd.h>

gid_t getgid(void);
1
2
3

其中，gid_t 是一个类型，通常是一个无符号整数类型，用于表示组 ID。

1.4通过 /proc 系统文件夹看进程

在Linux系统中，/proc文件系统提供了关于运行中进程的详细信息。你可以通过查看/proc文件系统中的特定目录和文件来获取有关进程的信息。下面是一些你可以在/proc文件系统中找到的有关进程的信息：

1. /proc/[PID]：这是一个以进程ID（PID）命名的目录，其中包含有关特定进程的详细信息。你可以使用命令 ls /proc/[PID] 来查看。

2. /proc/[PID]/status：此文件包含有关进程的各种状态信息，例如进程ID、父进程ID、进程状态、内存使用情况等。你可以使用命令 cat /proc/[PID]/status 查看。

3. /proc/[PID]/cmdline：此文件包含启动进程时使用的完整命令行参数。你可以使用命令 cat /proc/[PID]/cmdline 查看。

4. /proc/[PID]/exe：这是一个符号链接，指向正在运行的进程的可执行文件。你可以使用命令 ls -l /proc/[PID]/exe 查看。

5. /proc/[PID]/fd：这是一个目录，包含有关进程打开的所有文件描述符的信息。你可以使用命令 ls /proc/[PID]/fd 查看。

---

2.父进程与子进程

2.1介绍

在操作系统中，当一个进程（称为父进程）创建另一个新进程（称为子进程）时，父子进程之间建立了一种特殊的关系。这种关系具有以下特点和行为：

1. 父子关系：

• 子进程的父进程是创建它的进程，即父进程。
• 每个进程都有唯一的父进程。

2. PID关系：

• 子进程的PID（进程标识符）是由父进程调用fork()或类似系统调用创建的。
• 子进程的PPID（父进程标识符）与创建它的父进程的PID相同。

3. 资源继承：

• 子进程继承了父进程的大部分属性和资源，包括内存映像、文件描述符、信号处理器等。
• 子进程在创建时拥有父进程的副本，但在其生命周期中可以独立修改这些副本。

几乎所有进程都是由其他进程创建的，因为通常情况下，操作系统启动时会先创建一个初始进程（通常是init进程或systemd），然后其他进程都是由这些初始进程创建的。但是，也有一些特殊情况下的进程，比如内核线程和守护进程，它们可能是由操作系统内核直接创建的，而不是由其他进程创建的。总体而言，大多数进程都是有其父进程创建的。

2.2getpid() \getppid()

父进程和子进程之间的关系是一个重要的概念，它们之间的关系可以通过系统调用来获取。在Unix/Linux系统中，可以使用 getpid() 系统调用来获取当前进程的PID，使用 getppid() 系统调用来获取当前进程的父进程的PID。

以下是这两个系统调用的简要说明：

• getpid()：该系统调用返回调用进程的PID，即当前进程的PID。

• getppid()：该系统调用返回调用进程的父进程的PID，即当前进程的父进程的PID。

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

int main() {
    pid_t pid = getpid();      // 获取当前进程的PID
    pid_t ppid = getppid();    // 获取当前进程的父进程的PID

    printf("PID: %d\n", pid);
    printf("PPID: %d\n", ppid);

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

2.3 fork()函数—通过系统调用创建进程

我们要创建一个进程，那一定涉及到访问操作系统的内部数据，肯定也需要使用系统调用

fork 是一个系统调用（也是库函数），用于创建一个新的进程。它会复制调用进程（父进程）的内存和上下文，包括代码段、数据段、堆栈等，然后将这个副本分配给新创建的进程（子进程）。fork 系统调用的原型通常定义在 <unistd.h> 头文件中。

#include <unistd.h>

pid_t fork(void);
1
2
3

pid_t 是一个类型，用于表示进程 ID，fork 函数返回的是一个 pid_t 类型的值。

• fork 调用成功时，在父进程中返回子进程的 PID，而在子进程中返回 0。
• 如果 fork 调用失败，则返回一个负数，表示错误。

在 fork 调用后，父子进程都会继续执行 fork 调用之后的指令，但是它们会在不同的地址空间中运行，即它们各自拥有独立的内存空间。这意味着，父进程和子进程之间的数据是相互独立的，任何一个进程对内存的修改都不会影响到另一个进程。

父子进程代码共享的原理是采用写时拷贝（copy-on-write）。在 fork 调用后，操作系统并不会立即复制父进程的内存给子进程，而是让父子进程共享同一段内存空间。只有当其中一个进程试图修改共享的内存时，操作系统才会复制该内存页，确保修改不会影响到其他进程。这样做可以节省内存，并提高效率。

fork()函数疑问

1. 怎么理解fork（）是系统调用也是库函数

   fork 在 Unix-like 系统中既是一个系统调用，也是一个库函数，可以这样理解：

   1. 系统调用（System Call）：系统调用是操作系统提供给用户空间程序访问内核功能的一种机制。fork 系统调用是由操作系统内核实现的，用于创建一个新的进程。当用户程序调用 fork 时，实际上是请求操作系统内核为其创建一个新的进程，这需要通过系统调用来完成。

   2. 库函数：库函数是一组在编程时可调用的函数，这些函数通常包含在标准库或其他库中。在 Unix-like 系统中，C 标准库中包含了对 fork 函数的封装，这意味着用户程序可以通过调用 fork 库函数来发起对 fork 系统调用的请求，而不必直接调用系统调用。

   从用户程序的角度来看，fork 可以被视为一个库函数，因为它是通过调用库函数来实现的。

   从操作系统内核的角度来看，fork 是一个系统调用，因为它需要通过内核来创建新的进程。

fork 函数在调用后会返回两次，这是因为它是一个复制当前进程的系统调用。下面是对这两个返回值的解释：

1. 给父进程返回子进程的 PID：在父进程中，fork 返回新创建子进程的进程 ID（PID），这个 PID 是子进程的标识符，父进程通过这个 PID 可以识别并操作子进程。

2. 给子进程返回 0：在子进程中，fork 也会返回一个值，但是返回的是 0。这是因为在 Unix-like 系统中，子进程是通过复制父进程的地址空间而创建的，因此子进程从父进程继承了大部分的内存布局和数据。为了区分父进程和子进程，fork 在子进程中返回 0，表示这是子进程执行的代码路径。

3. fork函数为什么会返回两次：fork 函数在调用后会创建一个新的子进程（在return之前就已经创建好子进程了），新的子进程拥有父进程的副本。因此，fork 在执行时会返回两次：一次在父进程中（返回子进程的 PID），另一次在子进程中（返回 0）。这样做是为了让父进程和子进程可以根据返回值来执行不同的代码路径。

使用fork（）函数

#include<stdio.h>
#include<unistd.h>
#include<sys/types.h>
int main()
{
    printf("before fork:I'm a process, pid:%d, ppid:%d\n",getpid(),getppid());
    sleep(1);
    pid_t id=fork();
    if(id<0) return 1;//说明创建失败
    else if(id==0)
    {
        //只有子进程能进这里，我们就可以让子进程做自己的事
        printf("after fork:I'm a child process, pid:%d, ppid:%d\n",getpid(),getppid());
        sleep(2);
    }
    else 
    { 
        //只有父进程能进这里
        printf("after fork:I'm a father process, pid:%d, ppid:%d\n",getpid(),getppid());
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

---

3.进程状态

3.1进程排队

我们首先要知道：进程不是一直在运行的。进程放在了CPU上，也不是一直会运行的，可能在等待某种软硬件资源

而且计算机的资源相对来说一直是不够的，那么必然出现进程排队的情况，那么排队是怎么个排法呢？

• 排队是进程的task_struct结构体在排队——放到一个队列里

3.2教材上进程状态的表述——运行、阻塞、挂起

在操作系统中，进程的状态可以分为多种，常见的包括运行、阻塞和挂起。每种状态都对应着一个状态队列，用于存储处于相应状态的进程

1. 进程状态的本质：

• 进程状态通常被表示为整数值，这些整数值定义了进程当前所处的状态。在内核中，进程的状态由一个整型变量表示，通常称为状态字段。不同的操作系统可能会使用不同的状态值和命名，但通常包括就绪、运行、阻塞等状态。

2. 状态决定的后续动作：

• 进程的状态决定了操作系统对其后续动作的处理方式。不同状态的进程可能会有不同的处理逻辑，以确保系统的正常运行和资源的合理利用。
• 例如处于运行状态的进程会被分配 CPU 时间片并执行指令；处于阻塞状态的进程会被放入阻塞队列中等待某种事件的发生，如 I/O 操作的完成

运行

1. 一个 CPU 一个运行队列：

• 在操作系统中，为了有效地管理进程的调度和执行，通常会为每个 CPU 维护一个运行队列。这个运行队列存储了当前可运行的进程，即那些已经准备好被 CPU 调度执行的进程。

2. 运行队列结构体定义：

• 为了管理运行队列，可以定义一个结构体来表示，通常包括两个重要的字段：
  • num：表示队列中当前的进程数量，即队列长度。
  • q：一个指针，指向保存了 PCB（Process Control Block，进程控制块）信息的结构体。这个结构体可能是链表或其他数据结构，存储了就绪状态的进程的信息。

3. 已加载到运行队列的含义：

• 当一个进程被加载到运行队列中时，意味着它已经准备好被 CPU 随时调度执行了。这意味着进程已经完成了一些初始化工作，获取了所需的资源，并且已经被操作系统标记为可执行状态。它随时可以被操作系统的调度器选择，并分配 CPU 时间片来执行其任务。

阻塞

• 当进程需要等待某种事件发生时，例如等待 I/O 操作完成或等待某个信号，它会进入阻塞状态。在阻塞状态下，进程暂时停止执行，让出 CPU 给其他可以执行的进程。
• 对应的状态队列是阻塞队列，其中存储了因为等待某种事件而被阻塞的进程的信息。一旦等待的事件发生，进程就会从阻塞队列中移出，并重新进入就绪状态，等待 CPU 调度执行。

1. 阻塞状态有一个阻塞队列，这个队列通常由操作系统维护，用于存放因为等待某种事件而被阻塞的进程。

2. 阻塞队列通常与特定的硬件设备相关联。例如，如果一个进程等待磁盘 I/O 操作完成，那么它就会被放入磁盘 I/O 队列中。这样，当硬件设备完成相应的操作时，操作系统可以方便地找到并唤醒等待的进程。

3. 进程进入等待队列确实意味着它被链接到底层设备。这样，当设备就绪并且有了相应的数据或事件时，操作系统可以从等待队列中找到相应的进程，并唤醒它们以继续执行。

4. 当设备已经就绪时，操作系统会通知相关的进程，告诉它们可以执行了。这个状态由操作系统来管理，因为操作系统能够监控硬件设备的状态并作出相应的调度决策。

#include<stdio.h>

int main()
{
    int a=0;
    scnaf("%d",&a);
    printf("%d",a);
    return 0;
}
1
2
3
4
5
6
7
8
9

• 这段代码中，需要获取软硬件的资源所以进入阻塞状态
• 阻塞队列（等待队列)是由对应的的硬件提供的，scanf这里就是键盘
• 进程进入等待队列是把进程链入底层设备的一个过程！

这个过程：

1. 当进程执行到 scanf() 函数时，它会尝试从标准输入读取数据。如果标准输入是终端设备（比如键盘），则进程需要等待用户输入数据。此时，操作系统将会将进程状态从运行状态更改为阻塞状态，表示进程暂时无法继续执行，因为它在等待外部事件的发生。

2. 此时，进程的 task_struct 将从运行队列中移除，并加入到描述键盘的结构中，以便在键盘输入数据后能够唤醒这个进程。

3. 当用户输入数据并按下回车键后，操作系统会将输入的数据传递给进程，并将该进程的状态从阻塞状态更改为就绪状态。接着，进程将重新加入到运行队列中，等待 CPU 的调度执行。

4. 一旦进程再次被调度到 CPU 上执行，它将继续执行 printf() 函数，并输出用户输入的数据。然后进程执行完成，返回0，最终退出。

挂起

1. 进程进入挂起状态通常是因为系统资源已经极度紧张，没有足够的资源来继续运行所有进程。此时，操作系统会将一些不活跃的进程暂时挂起，以释放资源给其他更重要或更活跃的进程使用。

2. 挂起状态也可以称为阻塞挂起，因为进程在挂起状态下被阻塞，无法执行任何操作，直到被重新唤醒。

3. 在挂起状态下，操作系统可能会将进程的代码和数据从内存中转移到外部存储设备中，以节省内存空间。这样做的目的是为了释放内存资源，让其他活跃的进程有更多的空间来执行。

4. 挂起状态的意义在于，通过暂时挂起一些不活跃的进程，可以避免系统资源耗尽导致操作系统崩溃或无法响应。虽然挂起状态可能会导致一些进程的执行速度变慢，但这是为了整个系统的稳定性和可靠性考虑的。

3.3Linux中状态初步认识

一个进程可以有几个状态（在Linux内核里，进程有时候也叫做任务）进程的状态通常由几个不同的状态标识符表示。以下是一些常见的进程状态及其在内核源代码中的定义：

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 */
};
1
2
3
4
5
6
7
8
9
10

• R运行状态（running）: 并不意味着进程一定在运行中，它表明进程要么是在运行中要么在运行队列里。
• S睡眠状态（sleeping): 意味着进程在等待事件完成（这里的睡眠有时候也叫做可中断睡眠（interruptible sleep））
• D磁盘休眠状态（Disk sleep）有时候也叫不可中断睡眠状态（uninterruptible sleep），在这个状态的进程通常会等待IO的结束。
• T停止状态（stopped）： 可以通过发送 SIGSTOP 信号给进程来停止（T）进程。这个被暂停的进程可以通过发送 SIGCONT 信号让进程继续运行。
• X死亡状态（dead）：这个状态只是一个返回状态，你不会在任务列表里看到这个状态

---

好啦这次就到这里啦！！！也是才结束51假期，希望51数学建模能拿个不错的奖项吧
感谢大家支持