• 零基础Linux_11(进程)进程程序替换+实现简单的shell

    目录

    1. 进程程序替换

    1.1 程序替换原理

    1.2 execl 接口

    1.3 execv + execlp + execvp

    1.4 exec 调各种程序

    1.5 execle 接口

    2. 实现简单的shell

    2.1 打印提示和获取输入

    2.2 拆开输入的命令和选项

    2.3 创建进程和程序替换执行命令

    2.4 内建命令实现路径切换

    2.5 myshell里放置环境变量

    3. 传上git（附完整代码）

    4. 本篇完。

    1. 进程程序替换

    首先我们要知道，创建子进程的目的是什么？无非就是两种目的：

    • 想让子进程执行父进程代码的一部分。
    • 想让子进程执行一个全新的代码。

            我们之前所写的程序，子进程都是在执行父进程代码的一部分，而要想让子进程执行全新的代码，就需要进行进程程序替换。

            曾经创建的子进程和父进程是代码共享的，通过 if-else  同时执行（写时拷贝），经过同一个变量通过虚拟地址转化为物理地址，让父子进程得到不同的值，从而判断出来让父子进程执行不同的代码片段。这是我们之前的操作。

    如果我们想让创建出来的子进程，执行全新的程序呢？

            之前我们通过写时拷贝，让子进程和父进程在数据上互相解耦，保证独立性。如果想让子进程和父进程彻底分开，让子进程彻彻底底地执行一个全新的程序，我们就需要 进程的程序替换。

    为什么要进行程序替换？

    因为我们想让子进程执行一个全新的程序。

    那为什么要让子进程执行新的程序呢？

            我们一般在服务器设计的时候（Linux 编程）的时候，往往需要子进程干两件种类的事情：①让子进程执行父进程的代码片段（服务器代码…），②想让子进程执行磁盘中一个全新的程序（shell、想让客户端执行对应的程序、通过我们的进程执行其他人写的进程代码、C/C++ 程序调用别人写的 C/C++/Python/Shell/Php/Java...）

    1.1 程序替换原理

            程序替换原理：用fork创建子进程后执行的是和父进程相同的程序（但有可能执行不同的代码分支），子进程往往要调用一种exec函数 以执行另一个程序。

            当进程调用一种exec函数时，该进程的用户空间代码和数据完全被新程序替换，从新程序的启动例程开始执行。调用exec并不创建新进程，所以调用exec前后该进程的id并未改变。调用exec：

    • 将磁盘中的内存，加载入内存结构。
    • 重新建立页表映射，设执行程序替换，就重新建立谁的映射（下图为子进程建立）。
    • 效果：让父进程和子进程彻底分离，并让子进程执行一个全新的程序。 

            这里左边基本不发生变化，右边将新的磁盘上的程序加载到内存，并和当前进程的页表，重新建立映射，这就是进程替换。

    这个过程有没有创建新的进程呢？

            没有，因为子进程的内核数据结构根本没变，只是重新建立了虚拟的物理地址之间的映射关系。内核数据结构没有发生任何变化，包括子进程的pid都不变，说明没有创建新进程。

    1.2 execl 接口

    我们要调用接口，让操作系统去完成这个工作：系统调用。

    其实有六种以exec开头的接口函数（还有一个是系统调用接口），统称exec函数：

    1. #include 
    2.  
    3. int execl(const char *path, const char *arg, ...);
    4. int execlp(const char *file, const char *arg, ...);
    5. int execle(const char *path, const char *arg, ...,char *const envp[]);
    6.  
    7. int execv(const char *path, char *const argv[]);
    8. int execvp(const char *file, char *const argv[]);
    9. int execvpe(const char* file, char* const argv[], char* const envp[]);
    10.  
    11. int execve(const char *path, char *const argv[], char *const envp[]);

    l(list) : 表示参数采用列表

    v(vector) : 参数用数组

    p(path) : 有p自动搜索环境变量PATH

    e(env) : 表示自己维护环境变量

    这些函数如果调用成功则加载新的程序从启动代码开始执行，不再返回。

    如果调用出错则返回-1，所以exec函数只有出错的返回值而没有成功的返回值。

            如何进行程序替换？先从第一个 execl 这个接口讲，看看它怎么跑的。如果我们想执行一个全新的程序，我们需要做几件事情：（要执行一个全新的程序，以我们目前的认识，程序的本质就是磁盘上的文件）

    • 第一件事情：先找到这个程序在哪里。
    • 第二件事情：程序可能携带选项进行执行（也可以不携带）。

    明确告诉 OS，我想怎么执行这个程序？要不要带选项。

    简单来说就是：① 程序在哪？  ② 怎么执行？

    所以，execl 这个接口就必须得把这两个功能都体现出来。

    它的第一个参数是 path，属于路径。
    参数  const char* arg, ... 中的 ... 表示可变参数，命令行怎么写（ls, -l, -a） 这个参数就怎么填。ls, -l, -a 最后必须以 NULL 结尾，表示 "如何执行程序的" 参数传递完毕。

    代码演示：

    这里先创建linux_11目录，进入目录写Makefil和test.c：

     编译运行：

    代码运行后，自动执行了ls -l -a 命令，但是为什么没有打印第10行的代码？

            因为一旦替换成功，是会将当前进程的代码和数据全部替换的。所以自然后面的 printf 代码早就被替换了，这意味着该代码不复存在了。而第一个 printf 执行了的原因自然是因为程序还没有执行替换，

            所以，这里的程序替换函数用不用判断返回值？为什么？一旦替换成功，还会执行返回语句吗？返回值有意义吗？ 没有意义。

            程序替换不用判断返回值，因为只要成功了，就不会有返回值。 而失败的时候，必然会继续向后执行。只要有返回值，就一定是替换失败了。

    在上面的代码基础上引入进程创建：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5.  
    6. int main() 
    7. {
    8.     printf("我是父进程，%d\n", getpid());
    9.     pid_t id = fork();
    10.     if (id == 0) 
    11.     {
    12.         printf("我是子进程，%d\n", getpid());
    13.         execl("/usr/bin/ls", "ls", "-a", "-l", NULL);  // 让子进程执行替换
    14.  
    15.         exit(1);   // 只要执行了exit，就意味着 excel 系列函数失败了，终止子进程
    16.     }
    17.  
    18.     int status = 0; // 一定是父进程走到这
    19.     pid_t ret = waitpid(id, &status, 0);
    20.     if (ret == id) 
    21.     {
    22.         sleep(1);  
    23.         printf("父进程等待成功！退出码是: %d\n",WEXITSTATUS(status));
    24.     }
    25.  
    26.     return 0;
    27. }

    编译运行：

    成功执行代码，父进程也等待成功了。这里的子进程没有执行父进程的代码，执行了自己的程序。

    子进程执行程序替换，会不会影响父进程呢？

    不会，因为进程具有独立性。

    为什么？子进程是如何做到代码和数据做分离的呢？

            之前说过：fork 之后父子是共享的，如果要替换新的程序我能理解把新的程序的代码加载到内存里，子进程新的代码程序出来之后发生数据的写时拷贝，生成新的数据段。

    不是说代码是共享的吗？该如何去理解呢？

    当程序替换的时候，我们可以理解成：代码和数据都发生了写时拷贝，完成了父子分离。

    1.3 execv + execlp + execvp

    前面介绍的六种以exec开头的接口函数（还有一个是系统调用接口），统称exec函数：

    1. #include 
    2.  
    3. int execl(const char *path, const char *arg, ...);
    4. int execlp(const char *file, const char *arg, ...);
    5. int execle(const char *path, const char *arg, ...,char *const envp[]);
    6.  
    7. int execv(const char *path, char *const argv[]);
    8. int execvp(const char *file, char *const argv[]);
    9. int execvpe(const char* file, char* const argv[], char* const envp[]);
    10.  
    11. int execve(const char *path, char *const argv[], char *const envp[]);

    l(list) : 表示参数采用列表

    v(vector) : 参数用数组

    p(path) : 有p自动搜索环境变量PATH

    e(env) : 表示自己维护环境变量

    这些函数如果调用成功则加载新的程序从启动代码开始执行，不再返回。

    如果调用出错则返回-1，所以exec函数只有出错的返回值而没有成功的返回值。

            刚才我们学会了 execl 接口，我们下面开始学习更多的 exec 接口，它们都是用来替换的。下面我们先来讲解一下和 execl 很近似的 execv：

    1. int execl(const char *path, const char *arg, ...);
    2.  
    3. int execv(const char* path, char* const argv[]);

    path 参数和 execl 一样，关注的都是 "如何找到" 

    argv[ ] 参数关注的是 "如何执行"，是个指针数组，放 char* 类型，指向一个个字符串。

    大家在命令行上 $ ls -a -l ，在 execl 里我们是这么传的： "ls", "-a", "-l", NULL 。

    所以 execv 和 execl 只有传参方式的区别，一个是可变参数列表 (l)，一个是指针数组 (v)。

    值得注意的是，在构建 argv[] 的时，结尾仍然是要加上 NULL！

     编译运行：

    下面再用一下execlp函数：

    1. int execl(const char *path, const char *arg, ...);
    2.  
    3. int execlp(const char *file, const char *arg, ...);

    execlp，它的作用和 execv、execl 是一样的，它的作用也是执行一个新的程序。

    仍然是需要两步：① 找到这个程序   ② 告诉我怎么执行

            第一个参数 file 也是 "你想执行什么程序"，第二个参数 arg 是 "如何去执行它"。所以这一块的参数传递，和 execl 是一样的，唯一的区别是比 execl 多了一个 p。

            执行指令的时候，默认的搜索路径在环境变量中，所以这个 p 的意思是环境变量。这意味着：执行 execlp 时，会直接在环境变量中找，不用去输路径了，只要程序名即可。

            上面例子中的代码，无论是 execl 还是 execv，执行程序都得带上路径。而 execlp 可以不带路径，只说出你要执行哪一个程序（这个程序应该在环境变量中有）：

    编译运行：

            代码里出现的两个 ls 含义是不一样的，是不可以省略的，第一个参数是 "让系统去找你是谁的"，后面的一堆全代表的是 "你想怎么去执行它" 。

    现在讲了第1和2和4个，现在讲第5个execvp

    1. int execl(const char *path, const char *arg, ...);
    2. int execlp(const char *file, const char *arg, ...);
    3. int execle(const char *path, const char *arg, ...,char *const envp[]);
    4.  
    5. int execv(const char *path, char *const argv[]);
    6. int execvp(const char *file, char *const argv[]);
    7. int execve(const char *path, char *const argv[], char *const envp[]);

            execvp 也是带 p 的，执行 execvp 时，会直接在环境变量中找，只要程序名即可。简单来说就是 execv 的带 p 版本，将命令行参数字符串，统一放入数组中即可完成调用。

     编译运行：

    1.4 exec 调各种程序

    目前上面子进程执行的程序，全部都是系统命令，如果我们要执行自己写的 C/C++ 程序呢？

    如果我们要执行其他语言写的程序呢？

            我们前几章写的 Makefile 文件只能形成一个可执行程序，现在我们学习如何形成多个。比如，如果我们想一口气形成 2 个 可执行程序：假设有两个可执行程序：test.c 和 test2.cpp 我们期望用 test.c 调用 test2.cpp:

    也就是 C 语言的可执行程序调用 C++ 的可执行程序，我们先来设计一下 Makefile。

    我们需要在前面添加 .PHONY:all ，让伪目标 all 依赖 mytest 和 test2。

    如果不这样做，直接写，默认生成的是 test2，轮不到后面的 mytest。

    且 Makefile 默认也只能形成一个可执行程序，想要形成多个就需要用到 all 了：

    make一下：

    Makefile 搞定了，现在想用我的 test.c 去调用 test2 这个程序，如何做呢？

    先 pwd 获取得到 test2.cpp  的绝对路径：（调用时在路径最后在加上test2）

    通过使用 execl() 来调用自己写的程序:

    编译运行：

    成功用C 语言程序调用我们的 C++ 程序，调用python也是可以的：

     用vim写：

    然后直接用python解释器编译运行看看：

     在test.c中调用test3.py：

    调用各种语言都是可以的，这里就不演示了。

    1.5 execle 接口

    int execle(const char* path, const char* arg, ..., char* const envp[]);

    我们可以使用 execle 接口传递环境变量，相当于自己把环境变量导进去。

    打开 test2.cpp文件，我们加上几句环境变量：

     make然后直接./test2（有x权限就能这样，Python也是）

    PATH 是自带的环境变量，MYPATH 是我们自己的环境变量，没设置所以没打印出来。

    下面在 test.c，用 execle 给 test2.cpp 传递MYPATH 环境变量：

    编译运行：

    PATH没有打印，MYPATH更是看不到？

    把test2.cpp的PATH注释掉：

     编译运行：

     所以，为什么会出现这种情况？

    execle 接口，这个 e 表示的是 添加环境变量给目标进程，如果是自己的变量，那么是覆盖式的。如果你想把系统的环境变量 PATH 传给它，我们需要 extern 环境变量的指针申明：

     解开test2.cpp 的注释，编译运行：

     系统本来就没有 MYPATH，我们在外面export手动添加：

    上面这也证明了环境变量的全局属性，看到这，剩下类似的接口看下就懂了，这里就不演示了

            这么多接口，唯一的差别就是传参的方式不一样，有的带路径，有的不带路径，有的是列表传参，有的是数组传参，有的可带环境变量，有的不带环境变量。

            因为要适配各种各样的应用场景，使用的场景不一样，有些人就喜欢列表传参，有些人喜欢数组传参。所以就配备了这么多接口，这就好比 C++ 函数重载的思想。 

            execve 处于 man 2 号手册，execve 才属于是真正意义上的系统调用接口。刚才介绍的那些，实际上就是为了适配各种环境而封装的接口，每个的底层都调用execve：

    2. 实现简单的shell

            学到现在我们就可以更加清楚shell的运行机制了，bash是一个父进程，每输入一个指令就会创建一个子进程，并且进行相应的程序替换。

    现在我们就来简单的模拟实现一下：（这里退出linux_11创建一个linux_11_shell）

     写Makefile和myshell.c：

    2.1 打印提示和获取输入

    写myshell.c前先思考：shell 本质就是个死循环，先实现前两步写个框架：

    ① 打印显示提示符，比如：[rtx2@VM-8-14-centos linux_11_shell]$（这里就不获取了）    

    ② 获取用户输入的指令和选项，比如：" ls -a -l "，->用fgets

    man fgets：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. #define NUM 1024
    9. char command_line[NUM];   // 用来接收命令行内容
    10.  
    11. int main()
    12. {
    13.     while (1)
    14.     {
    15.         // ① 打印显示提示符，比如：[rtx2@VM-8-14-centos linux_11_shell]$（这里就不获取了）    
    16.         printf("[用户名@主机名 当前目录]# ");
    17.         fflush(stdout);
    18.  
    19.         // ② 获取用户输入的指令和选项，比如：" ls -a -l "，->用fgets
    20.         memset(command_line,'\0',sizeof(command_line) * sizeof(char));
    21.         if (fgets(command_line, NUM, stdin) == NULL) // 从键盘获取,stdin获取到C风格的字符串,默认添加\0
    22.         {
    23.             continue; // 读错了重新输入(基本不会读错)
    24.         }
    25.         printf("echo: %s\n", command_line); // 打印测试一下,后面注释掉
    26.     }
    27.  
    28.     return 0;
    29. }

    编译运行试试：

    为什么多打了一行空行？

    因为 command_line 里有一个 \n（fgets里获取到的），比如我们输入了ls -a -l，最后还会回车，

    fgets把回车也获取到了，command_line 里就有“ls -a -l \n\0”，我们把它替换成 \n 即可：

    1.  command_line[strlen(command_line) - 1] = '\0';  // 消除 '\n'
    2. '

     编译运行：

     至此，我们已经完成了提示用户输入和获取用户输入了，然后把echo打印的那一行注释掉。

    2.2 拆开输入的命令和选项

    下面我们需要拆开输入的命令和选项，比如：把 "ls -a -l" 拆成  "ls"  "-a"  "-l" 

    因为 exec 函数簇无论是列表传参还是数组传参，一定是要逐个传递的。

    我们可以使用以前学过的 strtok 函数，将一个字符串按照特定的分隔符打散，将子串依次返回：

     复习链接：C语言进阶⑬(字符串)(指针编程作业)(模拟实现字符串函数)__GR的博客-CSDN博客

    写代码并且讲拆开的命令和选项打印出来：

     用到for循环： 

    编译运行：

    成功拆开输入的命令和选项，把测试的for循环注释掉。

    2.3 创建进程和程序替换执行命令

    下面我们实现创建子进程，执行上面获取到的命令。

    1. #include 
    2.  
    3. int execl(const char *path, const char *arg, ...);
    4. int execlp(const char *file, const char *arg, ...);
    5. int execle(const char *path, const char *arg, ...,char *const envp[]);
    6.  
    7. int execv(const char *path, char *const argv[]);
    8. int execvp(const char *file, char *const argv[]);
    9. int execvpe(const char* file, char* const argv[], char* const envp[]);
    10.  
    11. int execve(const char *path, char *const argv[], char *const envp[]);

            这么多接口选哪个？我们拆开的命令已经带数组了，当然选带v的，路径让它自己找，就选带p的，所以选用execvp这个接口：

    编译运行：

    此时就可以调用各种命令了，但还有很多地方不够好，比如：如何让我们的命令带颜色呢？

    以前就看到过了这条命令，现在给我们myshell里的 ls 加上，在第3步给 ls 命令添加颜色：

    编译运行：

    为什么我们 cd.. 回退到上级目录时，我们的路径是不发生变化的？

    2.4 内建命令实现路径切换

            虽然系统中存在 cd 命令，但我们写的 shell 脚本中用的根本就不是这个 cd 命令。当你在执行 cd 命令时，调用 execvp 执行的实际上是系统特定路径下的 cd，它只影响了子进程，如果我们直接 exec* 执行 cd，那么最多只是让子进程进行路径切换。

            但是请不要忘了：子进程是一运行就完毕的进程，运行完了你切换它的路径，毫无意义。所以，我们在 shell 中，更希望谁的路径发生变化呢？答案是父进程（shell 本身）。

            所以，对我们来说我们此时就有一个需求了：如果有些行为是必须让父进程 shell 执行的，不想让子进程执行，这样的场景下，绝对不能创建子进程，因为一旦创建了子进程最后执行任务的是子进程，和父进程就无关了，只能是父进程自实现对应的代码。

    这部分由 shell 自己执行的命令，我们称之为 内建指令。

    内建指令本质是shell中的一个函数调用。

    实现路径切换的函数的函数：chdir

     在第4步创建子进程之前处理一下cd命令：

    编译运行：

    成功实现内建命令实现路径切换。

    2.5 myshell里放置环境变量

    前面 exec 的函数，是可以直接执行指定的命令、环境变量的。

    在myshell.c里放置环境变量，函数putenv：

    程序替换中，对于 exec 函数簇，如果如果函数名没 e，所有的环境变量是会被继承的。

            不带 e，环境变量依旧是可以被继承的，所以我们自己定一个环境变量的数组，它会覆盖我们的环境变量列表，我现在不想覆盖，我想新增，环境变量也会随之清空而丢失，所以我么需要一个专门存储环境变量的：

    编译运行：

    环境变量也放置成功了。

    环境变量的数据在进程的上下文中：

    ① 环境变量会被子进程继承下去，所以它会有全局属性。
    ② 当我们进行程序替换时， 当前进程的环境变量非但不会替换，而且是继承父进程的。

    环境你不传，默认子进程全部都会自动继承。

            如果你 exel 函数簇带 e，就相当于你选择了自己传，就会覆盖式地把原本的环境变量弄没，然后你自己交给子进程。如果不带 e，那么环境变量就会自己被子进程继承。

    如果既不想覆盖系统，也不想新增，所以我们采用 putenv 的方式向父 shell 导入新增一个它自己的环境变量，这样的话原始的环境变量还在，我们能在 shell 上下文上给它新增环境变量。所以，如何理解环境变量具有全局属性？

    因为所有的环境变量会被当前进程之下的所有子进程默认继承下去。

    如何在 shell 内部自己导入新增自己的环境变量？

    putenv，要注意的是，需要一个独立的空间，放置环境变量的数据被改写。

    最后，有没有想过shell的环境变量是哪里来的？

    环境变量是写在配置文件中的，shell启动的时候，通过读取配置文件获得起始的环境变量。

    3. 传上git（附完整代码）

    • git clone https://gitee.com/GRTX/TestLinux.git（自己的网站+用户名+密码）
    • cp myshell.c TestLinux/myshell.c（复制myshell到TestLinux目录下）
    • cd TestLinux
    • git add myshell.c
    • git commit -m '第一次提交实现的简单myshell程序'
    • git push（需用户名密码）

    刷新git后，成功上传，完整代码：

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. #define NUM 1024
    9. #define SIZE 32
    10. char command_line[NUM]; // 用来接收命令行内容
    11. char* command_argv[SIZE]; // 用来储存命令行参数
    12. char g_myval[64];// 写一个环境变量的buffer缓冲区
    13.  
    14. int main()
    15. {
    16.     while (1)
    17.     {
    18.         // 1. 打印显示提示符，比如：[rtx2@VM-8-14-centos linux_11_shell]$（这里就不获取了）    
    19.         printf("[用户名@主机名 当前目录]# ");
    20.         fflush(stdout);
    21.  
    22.         // 2. 获取用户输入的指令和选项，比如：" ls -a -l "，->用fgets
    23.         memset(command_line,'\0',sizeof(command_line) * sizeof(char));
    24.         if (fgets(command_line, NUM, stdin) == NULL) // 从键盘获取,stdin获取到C风格的字符串,默认添加\0
    25.         {
    26.             continue; // 读错了重新输入(基本不会读错)
    27.         }
    28.         command_line[strlen(command_line) - 1] = '\0';  // 消除 '\n'
    29.         // printf("echo: %s\n", command_line); // 打印测试一下,后面注释掉
    30.         
    31.         // 3.拆开输入的命令和选项
    32.         const char* dilim = " ";
    33.         command_argv[0] = strtok(command_line, dilim); // 第一次调用，传入原始字符串
    34.         int index = 1;
    35.         if(strcmp(command_argv[0],"ls") == 0)
    36.         {
    37.             command_argv[index++] = "--color=auto"; // 成立的话下面while循环从2开始跑
    38.         }
    39.         while(command_argv[index++] = strtok(NULL, dilim)) // 第二次调用，如果还要拆开原来的字符串，传入NULL
    40.         {
    41.             ; // 最后strtok获得的是\0，跳出循环
    42.         }
    43.         /*for(int i = 0; command_argv[i]; ++i) // 用来测试，等下注释掉
    44.         {
    45.             printf("command[%d] = %s\n", i, command_argv[i]);
    46.         }*/
    47.  
    48.         // 放置环境变量
    49.         if(strcmp(command_argv[0], "export") == 0 && command_argv[1] != NULL)
    50.         {
    51.             strcpy(g_myval, command_argv[1]);
    52.             int ret = putenv(g_myval);
    53.             if(ret == 0)
    54.             {
    55.                 printf("%s export success\n", command_argv[1]);
    56.             }
    57.             continue;
    58.         }
    59.         // 处理内置命令
    60.         if(strcmp(command_argv[0], "cd") == 0)
    61.         {
    62.             if(command_argv[1] != NULL)
    63.             {
    64.                 chdir(command_argv[1]);
    65.             }
    66.         }
    67.         // 4.创建进程和程序替换执行命令
    68.         pid_t id = fork();
    69.         if(id == 0)
    70.         {
    71.             printf("myshell子进程执行的：\n");
    72.             execvp(command_argv[0],command_argv); // 传入要执行的名字和数组
    73.             exit(1); // 只要到这里,子进程一定是替换失败了
    74.         }
    75.         int status = 0; // 只有父进程走到这里
    76.         pid_t ret = waitpid(id, &status, 0); // 阻塞等待
    77.         if(ret > 0)
    78.         {
    79.             printf("父进程等待成功,exit code: %d\n", WEXITSTATUS(status));
    80.         }
    81.     }
    82.     return 0;
    83. }

    4. 本篇完。

            进程控制内容是对前面进程学习内容的一种检验，很重要，尤其是进程程序替换，此时我们心中曾经的疑惑能够解开不少。还实现了简单的shell，相信大家对shell的理解也更深刻了。

            下一篇是进程部分的笔试选择题汇总：零基础Linux_12(进程)笔试选择题：冯诺依曼结构+操作系统+进程。

    下一大部分：基础IO，再下一大部分是进程间通信然后是进程信号。

    穿越回来复习顺便贴个下篇链接和下下篇链接：

    零基础Linux_12(进程)笔试选择题：冯诺依曼结构+操作系统+进程_冯诺依曼体系结构测试题-CSDN博客

    零基础Linux_13(基础IO_文件)文件系统接口+文件描述符fd+dup2函数_在linux平台o_binary的值是多少-CSDN博客

  • 相关阅读:
    C logistics
    算法练习- LeetCode 152. 乘积最大子数组
    Tabby Terminal 下载和安装,快速上手使用教程
    基于SSM的社会救助信息管理毕业设计源码211633
    深、浅拷贝之间的关系
    ubuntu20.4 执行sudo apt-get update出现错误 libnettle.so.6 动态链接库错误
    Python基础语法（三）—— 函数的定义和使用
    杰理之蓝牙流程处理，消息处理【篇】
    智能sql LLM
    步步深入 k8s 使用 pv pvc sc 在 nfs 基础上共享存储
  • 原文地址：https://blog.csdn.net/GRrtx/article/details/132011854