---

📙 作者简介 ：RO-BERRY
📗 学习方向：致力于C、C++、数据结构、TCP/IP、数据库等等一系列知识
📒 日后方向 : 偏向于CPP开发以及大数据方向，欢迎各位关注，谢谢各位的支持

---

---

---

1.进程创建

1.1 fork函数

在linux中fork函数时非常重要的函数，它从已存在进程中创建一个新进程。新进程为子进程，而原进程为父进程。
前面进行了基础介绍以及使用，这里我们再回顾一下

#include <unistd.h>
pid_t fork(void);
返回值：自进程中返回0，父进程返回子进程id，出错返回-1

进程调用fork，当控制转移到内核中的fork代码后，内核做：

• 分配新的内存块和内核数据结构给子进程
• 将父进程部分数据结构内容拷贝至子进程
• 添加子进程到系统进程列表当中
• fork返回，开始调度器调度.

当一个进程调用fork之后，就有两个二进制代码相同的进程。而且它们都运行到相同的地方。但每个进程都将可以开始它们自己的旅程

---

1.2 写时拷贝

通常，父子代码共享，父子在不写入时，数据也是共享的，当任意一方试图写入，便以写时拷贝的方式各自一份副本。具体见下图:

在这个图里可以看到，因为操作系统要保证进程的独立性，会进行写时拷贝，重新开辟一个空间拷贝一个副本，实现两个进程写入不同地址空间
注意：

页表是有权限控制的！！！这是为了保证我们程序运行的安全性，阻止我们的非法操作

1.3 为什么要写时拷贝

1. 创建子进程的时候，为什么不把父进程的数据直接给子进程？

1. 把数据给你，你不一定用；把数据给你，你不一定全用。把数据给你，你全部都用，不代表你现在就要全部都用。
2. 操作系统为了系统的效率，不浪费额外空间，在你需要写入的时候，操作系统得到信号，就能把所有数据给你

2.为什么是写时拷贝，而不是写时申请，拷贝多麻烦，申请一份新空间不就可以了?

对写的理解，对数据的操作无非增删查改，这也是需要完整数据操作的，例如a++，这也是在原数据之上进行操作，这也是为了确保程序的完整性

3.为什么我们在进行fork函数调用的时候，页表上对于数据是只读，但是在后面进行写时拷贝的时候，权限发生了改变？

这是因为我们的页表对于父子进程的数据初始就设置为只读权限，同问题一，当发生写时拷贝的时候，会告诉操作系统需要使用数据，就会发生缺页中断，然后改变权限，这里也是为了效率问题以及资源浪费还有程序安全性的问题

---

2.进程终止

2.1 退出码

我们学习C语言都知道，一般main函数写完我们想要的操作之后，都会在程序的最后写一个return 0

这个返回值叫做进程的退出码
一般0，表示进程执行成功 非0，表示失败
当返回为非0的时候，不同的数字会代表不同的失败情况

当我们返回值为1的时候

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
int main()
{
  printf("hello linux!\n");
  return 1;
}

我们使用指令
echo &?

程序是可以看到我们返回的值是多少的，程序根据我们的退出码就可以知道我们进程成功还是失败了，以及失败的原因是什么

这种错误退出码都会对应着一个错误描述

1.使用语言和系统自带的方法，进行转化
2.可以自定义

函数strerror

man strerror :C语言上将错误码转化为错误描述

函数使用：

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
int main()
{
  for(int i = 0;i < 200; i++)
  {
    printf("%d:%s\n",i,strerror(i));
  }
  return 1;
}

运行结果：

这里只展现部分，在输出行里，我们输出到133个之后，程序便没有了错误描述，也就是说Linux里默认退出码一共有133个

结论

1. main函数return返回的时候，表示进程退出，return xxx，返回的是退出码，可以设置退出码的字符串含义
2. 其他函数退出，仅仅表示函数调用完毕！

---

2.2 进程退出场景

通过2.1可以总结进程退出场景一共有以下三种:

• 代码运行完毕，结果正确
• 代码运行完毕，结果不正确
• 代码异常终止,进程出现异常

前两种好理解，最后一种不好理解
进程出现异常是进程收到了异常信号

例：
我们可以在进程运行的时候使用kill指令让进程收到异常信号

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
int main()
{
  while(1)
  {
    printf("I am a process,pid=%d\n",getpid());
    sleep(1);
  }
  return 0;
}

运行结果：

进程出现Floating point exception这是除0异常

进程收到的异常信号，每个信号都有不同的编号，不同的编号表明异常的原因

结论：

任何进程最终的执行情况，我们可以用两个数字表明具体执行情况，一个是进程编号，一个是进程退出码

---

2.3 进程常见退出方法

正常终止（可以通过 echo $? 查看进程退出码）：

1. 从main函数，通过return返回

一般都是这个方法不用介绍

2. 调用exit函数

exit为进程终止函数

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
int main()
{
  while(1)
  {
    printf("I am a process,pid=%d\n",getpid());
    sleep(1);
    exit(3);     //以错误码3退出
  }
  return 0;
}

运行结果:

exit就是用来终止进程的，exit(退出码)
在我们的进程代码中，任何地方调用exit，都表示进程退出

3. _exit

man _exit：此函数用法和exit一模一样

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
int main()
{
  while(1)
  {
    printf("I am a process,pid=%d\n",getpid());
    sleep(1);
    _exit(3);
  }
  return 0;
}

运行结果：

📖exit与_exit区别
我们举例说明

• 代码1： 测试exit

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
int main()
{
  printf("I am a process");  //这里没有带换行
  sleep(3);
  exit(1);
}

运行结果： 三秒后屏幕进行了打印

• 代码2： 测试_exit

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
int main()
{
  printf("I am a process");
  sleep(3);
  _exit(1);
}

运行结果： 屏幕啥也没有，执行了两次均啥也没看见

结论：

exit支持刷新缓冲区
_exit不支持刷新缓冲区

注意：
我们之前所谈的和缓冲区(进度条之类)，绝对不是操作系统里的缓冲区

---

3. 进程等待

3.1 进程等待必要性

• 之前讲过，子进程退出，父进程如果不管不顾，就可能造成‘僵尸进程’的问题，进而造成内存泄漏。
• 另外，进程一旦变成僵尸状态，那就刀枪不入，“杀人不眨眼”的kill -9 也无能为力，因为谁也没有办法杀死一个已经死去的进程。
• 最后，父进程派给子进程的任务完成的如何，我们需要知道。如，子进程运行完成，结果对还是不对，或者是否正常退出。
• 父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息

为什么要进行等待？
1.父进程通过wait方式，回收子进程的资源(必然)
2.通过wait方式，获取子进程的退出信息(可选)

3.2 wait方法

man 2 wait

默认会进行阻塞等待，等待任意一个进程
返回值：
>0等待成功，等待的子进程的pid
<0等待失败

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
  pid_t id =fork();
  if(id == 0)
  {
    //child
    int cnt=5;
    while(cnt)
    {
      printf("child is running, pid: %d,ppid: %d\n",getpid(),getppid());
      sleep(1);
      cnt--;
    }
    printf("子进程准备退出，马上变成僵尸进程\n");
    exit(0);
  }
  printf("父进程休眠\n");
  sleep(15);
  printf("父进程开始回收\n");
  //father
  pid_t rid = wait(NULL);          //阻塞等待
  if(rid > 0)
  {
    printf("wait success,rid: %d\n",rid); //这里应该拿到子进程pid
  }
  printf("父进程会回收僵尸成功\n");
  sleep(10);

  return 0;
}

运行结果：

可以看到一开始父子进程一起运行，后来子进程退出变为僵尸进程，最后父进程对子进程进行了回收，僵尸进程不见了

---

3.2 waitpid方法

pid_ t waitpid(pid_t pid, int *status, int options);

返回值：

当正常返回的时候waitpid返回收集到的子进程的进程ID；
如果设置了选项WNOHANG,而调用中waitpid发现没有已退出的子进程可收集,则返回0；
如果调用中出错,则返回-1,这时errno会被设置成相应的值以指示错误所在；

参数：

pid：
Pid=-1,等待任一个子进程。与wait等效。
Pid>0.等待其进程ID与pid相等的子进程。
status:
WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）
WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）
options:
WNOHANG: 若pid指定的子进程没有结束，则waitpid()函数返回0，不予以等待。若正常结束，则返回该子进程的ID。

• 如果子进程已经退出，调用wait/waitpid时，wait/waitpid会立即返回，并且释放资源，获得子进程退
  出信息。
• 如果在任意时刻调用wait/waitpid，子进程存在且正常运行，则进程可能阻塞。
• 如果不存在该子进程，则立即出错返回。

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
  pid_t id =fork();
  if(id == 0)
  {
    //child
    int cnt=5;
    while(cnt)
    {
      printf("child is running, pid: %d,ppid: %d\n",getpid(),getppid());
      sleep(1);
      cnt--;
    }
    exit(1);
  }
  int status = 0;
  pid_t rid = waitpid(id,&status,0);          //阻塞等待
  if(rid > 0)
  {
    printf("wait success, rid: %d, status: %d\n",rid,status);
  }

  return 0;
}

执行结果：

rid输出为12231，为子进程的pid，说明函数使用成功，那为什么status=256呢？这里的status如何进行理解

3.3 获取子进程status

• wait和waitpid，都有一个status参数，该参数是一个输出型参数，由操作系统填充。
• 如果传递NULL，表示不关心子进程的退出状态信息。
• 否则，操作系统会根据该参数，将子进程的退出信息反馈给父进程。
• status不能简单的当作整形来看待，可以当作位图来看待，具体细节如下图（只研究status低16比特位）

如上图，我们的status就会被写成32为编码(前16位不管)，后十六位分别代表着退出码以及信号编号，中间有一位也不需要管。
这是因为我们任何进程最终的执行情况，我们需要用两个数字表明具体执行情况，一个是进程编号，一个是进程退出码，在这里我们的status则代表了这两个数字

status:256 由32为编码得到
0000 0000 0000 0000 0000 0001 0000 0000
此处退出码为1，表示进程成功运行
信号编号为0，表示进程成功运行

测试代码：

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/wait.h>
int main()
{
  pid_t id =fork();
  if(id == 0)
  {
    //child
    int cnt=5;
    while(cnt)
    {
      printf("I am child process, pid: %d,ppid: %d, cnt: %d\n",getpid(),getppid(),cnt);
      sleep(1);
      cnt--;
    }
    sleep(1);
    exit(1);
  }
  int status = 0;
  pid_t rid = waitpid(id,&status,0);          //阻塞等待
  if(rid > 0)
  {
    printf("wait success, rid: %d, status: %d,exit signo: %d,exit code: %d\n",rid,status,status&0x7F,(status>>8)&0xFF);
  }

  return 0;
}

1. 正常退出

2. 被信号所杀

上面我们使用位运算才得到的status，我们可以使用如下两个宏来获取status
WIFEXITED(status): 若为正常终止子进程返回的状态，则为真。（查看进程是否是正常退出）
WEXITSTATUS(status): 若WIFEXITED非零，提取子进程退出码。（查看进程的退出码）

3.4 阻塞与非阻塞等待

我们上面子进程在运行的时候，只有子进程在进行打印，父进程在进行阻塞等待，它其实能进行阻塞等待也能进行非阻塞等待

阻塞就是调用wait函数的时候，父进程会卡在这里，直到我们的子进程结束，wait才会返回，也就是说父进程在进程调用的时候，发现子进程状态没有退出，父进程就进入了等待队列，进行等待状态

pid_t waitpid(pid_t pid, int *status, int options);
在这里第三个参数options默认为0表示阻塞等待，这个参数还能被设置为WNOHANG，这是一个宏

WNOHANG : return immediately if no child has exited.
它的作用是：如果父进程在调用的时候，发现子进程没有退出，waitpid会以出错的形式进行返回

这种方式就叫非阻塞

代码实现：

#include <stdio.h> 
#include <unistd.h>
#include <stdlib.h>
#include <sys/wait.h>
int main()
{
  pid_t pid;
 
  pid = fork();
  if(pid < 0)
  {
    printf("%s fork error\n",__FUNCTION__);
    return 1;
  }
  else if( pid == 0 )
  { //child
    printf("child is run, pid is : %d\n",getpid());
    sleep(5);
    exit(1);
   }
  else
  {
    int status = 0;
    pid_t ret = 0;
    do
    {
      ret = waitpid(-1, &status, WNOHANG);//非阻塞式等待
      if( ret == 0 )
      {
        printf("child is running\n");
      }
      sleep(1);
    }while(ret == 0);
 
    if( WIFEXITED(status) && ret == pid )
    {
      printf("wait child 5s success, child return code is :%d.\n",WEXITSTATUS(status));
    }
    else
    {
      printf("wait child failed, return.\n");
      return 1;
    }
  }
  return 0;
}

运行结果：

---

4.进程程序替换

我们的程序只能执行我们的代码
如果我们创建的子进程，想执行其他程序的代码呢？

这种操作就可以使用我们的进程程序替换操作来解决

4.1 替换原理

用fork创建子进程后执行的是和父进程相同的程序(但有可能执行不同的代码分支),子进程往往要调用一种exec函数，以执行另一个程序。
当进程调用一种exec函数时,该进程的用户空间代码和数据完全被新程序替换,从新程序的启动例程开始执行。调用exec并不创建新进程,所以调用exec前后该进程的id并未改变。

4.2 替换函数

其实有六种以exec开头的函数,统称exec函数

#include <unistd.h>`
int execl(const char *path, const char *arg, ...);
int execlp(const char *file, const char *arg, ...);
int execle(const char *path, const char *arg, ...,char *const envp[]);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execve(const char *path, char *const argv[], char  *const envp[]);

man execl

4.3命名理解

这些函数原型看起来很容易混,但只要掌握了规律就很好记。

l(list) : 表示参数采用列表
v(vector) : 参数用数组
p(path) : 有p自动搜索环境变量PATH
e(env) : 表示自己维护环境变量

---

4.4 execl函数代码实现

int execl(const char *path, const char *arg, ...);

参数：

const char *path:路径以及文件名
const char *arg:执行操作
...:三个点为可变参数

可变参数如何理解呢？
类比printf函数

man 3 printf

printf函数的第三个参数也为三个点，在这里的含义也为可变参数，因为这个参数数量不确定

注： 函数最后要以NULL结尾

代码实现LS操作：

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

int main()
{
  printf("I am a process,pid: %d\n",getpid());
  printf("exec begin...\n");

  execl("/usr/bin/ls","ls","-a","-l",NULL);   //NULL   不是 "NULL"
  
  printf("execl end...\n");

  return 0;
}

运行结果：

---

代码实现top操作：

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

int main()
{
  printf("I am a process,pid: %d\n",getpid());
  printf("exec begin...\n");

  execl("/usr/bin/top","top",NULL);   //NULL   不是 "NULL"
  //execl("/usr/bin/ls","ls","-a","-l",NULL);   //NULL   不是 "NULL"
  
  printf("execl end...\n");

  return 0;
}

运行结果：

这里我们使用了我们自己的程序，就实现了系统的指令，这就叫做程序替换！！

4.5 细节处理

1. 大家有没有发现上面我们的execl函数后面还有一个printf函数输出end没有进行输出，这是为什么？

程序替换一旦成功，exec后续的代码不再执行，因为被替换掉了

2. exec函数的返回值去哪里了？

• 这些函数如果调用成功则加载新的程序从启动代码开始执行,不再返回。
• 如果调用出错则返回-1
• 所以exec函数只有出错的返回值而没有成功的返回值。
• 如果路径文件不存在则会失败

3. 程序替换后会创建新进程吗？

不会创建新进程，pid不会变，这是一个进程，只不过输出内容发生了改变

4. 创建一个进程，是先创建pcb，地址空间，页表等，还是先把程序加载到内存？

先创建先创建pcb，地址空间，页表等，程序替换所做的本质工作就是加载！

【补充】

我们使用exec函数使用的是标准传参，也可以非标准传参
exec*可移植性系统的指令，无论是什么语言，只要能在Linux下运行，都能进行执行

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

int main()
{
  printf("I am a process,pid: %d\n",getpid());
  printf("exec begin...\n");

  execl("/usr/bin/top","/usr/bin/top",NULL);   //NULL   不是 "NULL"
  //execl("/usr/bin/ls","ls","-a","-l",NULL);   //NULL   不是 "NULL"
  
  printf("execl end...\n");

  return 0;
}

运行结果：

4.5 学习各种exec接口

execlp

int execlp(const char *file, const char *arg, ...);

execlp接口比execl接口名字上多了一个p，p表示PATH，也就是你不用告诉系统程序在哪里，只需要告诉我名字是什么，系统替换的时候，会自动去PATH环境变量中查找

程序代码：

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

int main()
{
  printf("I am a process,pid: %d\n",getpid());
  printf("exec begin...\n");

  //execlp("/usr/bin/top","/usr/bin/top",NULL);   //NULL   不是 "NULL"
  execlp("ls","ls","-a","-l",NULL);   //NULL   不是 "NULL"
  
  printf("execl end...\n");

  return 0;
}

运行结果：

注意：

execlp("ls","ls","-a","-l",NULL);
这里的第一个ls表示你想执行谁，第二个ls表示你想怎么执行，这个是不重复的

execv接口

int execv(const char *path, char *const argv[]);

参数：

const char *path:目标路径
char *const argv[]:命令行参数表【数组】与main函数中的argv功能相仿

名称中带V，指的是vector，数组

代码实现：

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

char *argv[]={(char*)"ls",(char*)"-a",(char*)"-l"};
int main()
{
  printf("I am a process,pid: %d\n",getpid());
  printf("exec begin...\n");

  //execlp("/usr/bin/top","/usr/bin/top",NULL);   //NULL   不是 "NULL"
  execv("/usr/bin/ls",argv);   //NULL   不是 "NULL"
  
  printf("execl end...\n");

  return 0;
}

运行结果：

execvp接口

int execvp(const char *file, char *const argv[]);

名称带P，写入文件名即可
代码实现：

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

char *argv[]={(char*)"ls",(char*)"-a",(char*)"-l"};
int main()
{
  printf("I am a process,pid: %d\n",getpid());
  printf("exec begin...\n");

  //execlp("/usr/bin/top","/usr/bin/top",NULL);   //NULL   不是 "NULL"
  execvp("ls",argv);   //NULL   不是 "NULL"
  
  printf("execl end...\n");

  return 0;
}

运行结果：

execle

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

名称中带e，代表的是与环境变量挂钩

我们先试用execl接口实现C语言代码替换执行C++代码，获取C++的环境变量
Makefile

.PHONY:all
all:test myprocess
test:test.cc
	  g++ -o $@ $^ -std=c++11
myprocess:myprocess.c
		gcc -o $@ $^
.PHONY:clean
clean:
	rm -f myprocess test

这里makefile要实现编译俩个文件，需要在前面写一个依赖关系all
后缀为.cc/cpp/cxx的都是C++文件后缀

myprocess.c

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

char *argv[]={(char*)"ls",(char*)"-a",(char*)"-l"};
int main()
{
  printf("I am a process,pid: %d\n",getpid());
  printf("exec begin...\n");

  execl("./test","test",NULL);   //NULL   不是 "NULL"
  //execvp("ls",argv);   //NULL   不是 "NULL"
  
  printf("execl end...\n");

  return 0;
}

test.cc

#include<iostream>
using namespace std;

int main(int argc,char *argv[],char *env[])
{
  for(int i=0; env[i]; i++)
  {
    printf("env[%d]: %s\n", i, env[i]);
  }
  cout << "hello C++" << endl;
  return 0;
}

执行结果：

进程程序替换不会替换掉环境变量数据
想单纯添加环境变量可以在代码里使用putenv函数

回归正题，execle就是可以添加全新的环境变量表

代码正文：

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

char *argv[]={(char*)"ls",(char*)"-a",(char*)"-l"};
int main()
{
  char *const env[] ={(char*)"haha=hehe",(char*)"sss=adadada"};
  printf("I am a process,pid: %d\n",getpid());
  printf("exec begin...\n");

  execle("./test","test",NULL,env);   //NULL   不是 "NULL"
  //execvp("ls",argv);   //NULL   不是 "NULL"
  
  printf("execl end...\n");

  return 0;
}

运行结果：

---

结尾

这些接口使用功能大差不差，知识在使用上有所区别，传参方式不同，为了适应不同的使用场景
下节课让我们来使用以上讲的东西制作一个shell外壳！！