Linux 进程控制相关函数

进程终止

进程终止就是退出一个进程
在我们学过的c语言函数中，我们都会写主函数main，写完主函数都会return 0；其实这就是终止主函数进程的一个语句。例如以下代码

int main()
{
	printf("hello WhiteShirtI\n");
	return 0;
}

这是一个普通的语句，就是打印一句话后，程序就结束了。但是我们如果把return 0写在打印语句之前，那么程序运行到return的时候就结束了，就不会运行到打印的那条语句了。

void exit(int status)

exit()函数是一个库函数，哪个进程调用就退出哪个进程，再将exit的status参数返回给父进程

main.c

//main.c
#include <stdio.h>
#include <stdlib.h>

int main()
{
	exit(0);
	printf("Hello WhiteShirtI\n");
	return 0;
}

运行结果

我们发现并没有打印任何东东西

void _exit(int status)

_exit()并不是一个库函数，而是系统调用接口，功能也是退出调用的进程，并将status参数返回给父进程
main.c

//main.c
#include <stdio.h>
#include <unistd.h> //系统调用接口头文件

int main()
{
	_exit(0);
	printf("Hello WhiteShirtI\n");
	return 0;
}

并没有打印任何东西
库函数和系统调用接口的关系：库函数封装了系统调用接口，原因是系统调用接口对用户不太友好。
这三种终止进程的方式有什么不同呢？

1. return是等到进程退出的时候会刷新缓冲区，如果return在main函数中退出，整个进程才会退出
   main.c

//main.c
int main()
{
	printf("hello WhiteShirtI");
	sleep(5);;
	return 0;
}

虽然printf()函数在sleep的前面，但是打印并没有换行。也就是没有手动刷新缓冲区，所以直到运行5秒后，return进程结束才会刷新缓冲区，打印hello WhiteShirtI。

2. exit()函数和return一样，进程退出后会刷新缓冲区，但是exit()是可以在任意位置调用，一旦调用就会退出调用的进程
3. _exit()系统调用接口是当进程退出的时候直接释放资源，并不会刷新缓冲区
4. 以上三种进程退出方式都属于正常进程退出，会根据返回值向父进程表示退出原因

异常退出：程序崩溃，由于某种错误导致程序没运行完就突然退出

进程等待

进程等待就是父进程等待子进程的退出，获取子进程的返回值，从而避免产生僵尸进程

pid_t wait(int *status)

wait()函数是阻塞等待任意一个字进程退出，获取子进程的返回值到status指向的空间中，并释放子进程资源，返回退出的子进程的pid
阻塞：为了完成某个功能发起一个调用，若当前不具备完成功能的条件，则调用后不返回，一直等待
非阻塞：为了完成某个功能发起一个调用，若当前不具备完成功能的条件，则立即报错返回，通常需要循环等待
wait()是阻塞等待
zombie.c

	//zombie.c
   #include <stdio.h>
   #include <stdlib.h>
   #include <unistd.h>
   
   int main()
   {
       pid_t pid = fork();
       if (pid == 0)
       {
          sleep(5);
          exit(0);
      }
      wait(NULL);
      while(1)
      {
          sleep(1);
          printf("WhiteShirtI\n");
      }
      return 0;
  }

进程进行了进程等待，并没有产生僵尸进程

pid_t waitpid(pid_t pid, int *status, int options)

waitpid()函数的参数pid的作用

• 若 == -1，则表示等待任意一个子进程退出
• 若 > 0, 则表示等待指定的子进程退出

status：输出型参数，传入一个int空间的首地址，获取退出的子进程的返回值
options：选项参数

• 若 == 0,则表示默认阻塞等待；
• WNOHANG,将waitpid设置为非阻塞，没有子进程已经退出的话就立即报错返回

返回值：若等待到了子进程退出则返回子进程的pid；若有子进程但是没有退出，非阻塞，则返回0；出错返回-1；

wait() 和waitpid() 的关系：wait(status) == waitpid(-1,status,0)

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

  int main()
  {
      pid_t pid = fork();
      if (pid == 0)
      {
         sleep(5);
         exit(0);
      }
      int res;
      while((res = waitpid(pid, NULL, WNOHANG)) == 0)
      {
          printf("没有子进程退出,等一下来看\n");
      }
      while(1)
      {
          sleep(1);
          printf("WhiteShirtI\n");
      }
      return 0;
  }

循环进程等待，如果没有子进程退出，就去执行其他任务，当有子进程退出，就可以释放子进程的资源了，就不会产生僵尸进程。

非阻塞操作相对于阻塞操作的优点：对cpu利用更加充分，不用一直等待，但是必须循环进行等待
wait和waitpid并不是只处理刚退出的进程，而是对已经退出的进程进行处理(不管什么时候退出)

看看中间status参数的作用

   #include <stdio.h>
   #include <stdlib.h>
   #include <unistd.h>
   
   int main()
   {
       pid_t pid = fork();
       if (pid == 0)
       {
          sleep(5);
          exit(255);
      }
      int res;
      int status;
      while((res = waitpid(pid, &status, WNOHANG)) == 0)
      {
          sleep(1);
          printf("没有子进程退出,等一下来看\n");
      }
      printf("status : %d\n",status);
      while(1)
      {
          sleep(1);
          printf("WhiteShirtI\n");
      }
      return 0;
  }

将exit(0)改为exit(255)后，为什么status会是65280呢？
65280转化成16进制就是0xFF00。

再改为exit(66)后，status为16896，转化为16进制是0x4200，再改为exit(256)后，status为0，转化为16进制就是0x0000。我们可以发现status只用了低16位中的高8位来存储地址

子进程的退出返回值，实际只有一个字节来存储空间，也就意味着返回值最好不要大于255
将address = status >> 8，右移8位后，再&0xff，只要低8位

#include <stdio.h>
   #include <stdlib.h>
   #include <unistd.h>
   
   int main()
   {
       pid_t pid = fork();
       if (pid == 0)
       {
          sleep(5);
          exit(66);
      }
      int res;
      int status;
      while((res = waitpid(pid, &status, WNOHANG)) == 0)
      {
          sleep(1);
          printf("没有子进程退出,等一下来看\n");
      }
      printf("status : %d\n",(status >> 8) & 0xff);
      while(1)
      {
          sleep(1);
          printf("WhiteShirtI\n");
      }
      return 0;
  }

但是我们知道进程退出有正常退出还有异常退出，如果子进程是异常退出，那么获取它的返回值就毫无意义，所以获取一个进程的返回值的前提是这个进程是正常退出的
那我们如何判断子进程是否是正常退出呢？
我们都知道，在status变量中低16位中的高8位是存放了进程退出的返回值，那低8位有什么作用呢，在低8位中的高一位是core dump标志，core dump标志是核心传储，就是程序异常退出时，会保存程序的运行信息，便于事后调试。可以通过ulimit -a查看是否core dump标志是否打开；默认是关闭的，原因是core file文件非常大，占空间，还存在一定的安全隐患

而在低7位中，是用来保存了程序异常退出的信号值，那什么是信号呢？信号就是通知进程发生了某个异常事件，中断当前进程操作，去处理异常事件。在我们生活中也有很多信号，下课铃声和上课铃声，闹钟等。都在提醒我们应该去处理哪些事件。而在操作系统中的信号的体现实际是一个数字，数字就代表了某个异常事件，程序因为异常退出后，会将异常退出事件信号保存到低7位中

通过以上知识总结：如果status低7位全为0，则表示程序正常退出，否则表示程序异常退出
所以我们可以用status & ox7f是否等于0来判断程序是否正常退出，正常退出就打印返回值，异常退出就不用打印返回值了。
但是操作系统为我们提供了两个接口，专门处理status的

• WIFEXITED(status)–用于根据status判断子进程是否正常退出 ==>status & 0x7f == 0
• WEXITSTATUS(status)–从status中取出子进程退出返回值==> (status>>8)&0xff
  zombie.c
  
  运行上述代码，进程属于正常退出，会打印两次status的返回值
  

程序替换

我们都知道，创建子进程的目的有两个，第一个是与父进程做相同的事，分摊压力；另一个是让子进程做一些有危险的事，即使异常也不会影响主进程。那么想让子进程做其他的事，可以通过fork()函数的返回值不同进行分流。
但是这种方式存在缺陷，1、程序耦合度非常高，功能代码都是在一个程序中编写的，想要改变子进程的功能处理流程，就需要修改整个程序的代码，让整个程序重新进行运行编译；2、程序体积非常大

解决这个问题的最好办法就是程序替换
程序替换就是替换一个进程正在调度的程序信息(pcb)，将另一个程序加载到内存中，让原有的pcb不再调度原程序，而去调度这个新的程序。
在父子进程中，子进程几乎复制了父进程所有信息。下面是进程替换前后变化图

程序替换本质就是替换pcb在内存中对应的代码和数据(将新的程序加载到内存中，更新页表信息,重新初始化虚拟地址)，让进程pcb重新开始调度新的程序运行

理解了程序替换，那我们如何在diam中实现程序替换呢？
exec函数族–实现进程的程序替换

• 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, charconst argv[]);
• int execve(const char *path, char *const argv[], char *const envp[]); 系统调用接口

以上函数区别：l 和 v、有无p、有无e
以上函数成功都没有返回值，如果发生错误会返回-1

1. int execl(const char *path, const char *arg, …);
   参数const char *path是带有路径的新程序名称，就是用这个程序替换进程正在调度运行的程序；参数const char *arg是新程序的参数，后面的省略号是不定参，结尾必须以NULL结尾
   
   执行到execl函数时，会到第一个参数的路径上找到ls程序，然后传入参数"ls"和"-l"
   运行结果：
   
   如果将printf()函数放在execl()函数后面，就不会执行printf()函数，因为进行程序替换后，之前的进程就会退出，并不会又回去运行原先的程序，但是我们一般不会直接让主进程去替换，而是创建子进程，让新程序替换掉子进程
2. l和v的区别在于程序运行参数的赋予方式不同，l通过不定参完成；v用过字符串指针数组进行赋值。int execv(const char *path, char const argv[]);
   
   定义一个用来传参数的数组，注意最后结尾必须用NULL结尾，运行结果
   
3. 有无p区别在于第一个参数执行新程序的时候，是否需要带路径，默认会去PATH环境变量指定的路径下查找
   
   "/usr/bin"是我PATH默认的路径，可以直接使用execvp函数，将程序名称传进去就可以正确执行。前提必须保证新的程序在我们PATH默认路径下
   
4. 有无e区别在于这个进程的环境变量是否需要重新初始化，有e则表示重新初始化，无e则表示使用默认的环境变量。int execve(const char *path, char *const argv[], char *const envp[]);有e的会将环境变量存放在envp字符类型的指针数组中。
   这个execve并不是库函数，而是系统调用接口，前面5个都是库函数，封装了execve系统调用接口

学了程序替换，我们来理解一下为什么执行一个程序main，只需要./main就可以执行了呢？
当我们在shell中输入一个命令，shell会对我们的输入进行解析，得到程序名称，然后创建子进程，并且将子进程的程序替换为当前解析出来的程序