引言

在Linux系统中，进程管理是核心功能之一。理解进程的创建、执行和终止是系统编程中的基础。本文将深入探讨Linux中的进程控制机制，包括进程的生命周期、父子进程的交互、以及进程状态的管理

1. 进程创建：fork()函数

在Linux操作系统中，fork()是用于创建新进程的主要系统调用。通过此函数，当前进程（父进程）创建一个新的进程（子进程），子进程是父进程的一个复制品。

关键点：

• 父进程和子进程的关系：父进程通过fork()返回子进程的PID进行标识和管理，而子进程中fork()返回0，以区分两者的执行流。
• 内存和资源的复制：fork()实际上在内存层面采用了写时拷贝技术，优化了资源的使用。
• 代码示例：

  #include <unistd.h>
  #include <stdio.h>
  
  int main() {
      pid_t pid = fork();
      if (pid == 0) {
          printf("This is the child process.\n");
      } else {
          printf("This is the parent process. Child PID: %d\n", pid);
      }
      return 0;
  }
  

  

• 代码运行完毕，结果正确
• 代码运行完毕，结果不正确
• 代码异常终止

 那么我们如何终止进程呢？

 异常退出

ctrl + c ，信号终止

 首先可以main直接return，表示进程终止（非main函数return叫做函数结束）其次，代码调用exit函数也可以终止进程。在代码的任意位置调用都表示进程退出。最后，我们还可以采用_exit,这是一个system call.区别是什么呢？Exit会在退出的时候刷新缓冲区，_exit不会。目前我们所说的缓冲区不是内核缓冲区，一定不在操作系统内部，因为exit本质是调用_exit。

 _exit函数

#include <unistd.h>
void _exit(int status);
参数：status 定义了进程的终止状态，父进程通过wait来获取该值
说明：虽然status是int，但是仅有低8位可以被父进程所用。所以_exit(-1)时，在终端执行$?发现返回值
是255。

 exit函数

#include <unistd.h>
void exit(int status);

1. 执行用户通过 atexit 或 on_exit 定义的清理函数。

2. 关闭所有打开的流，所有的缓存数据均被写入

3. 调用 _exit

 进程等待

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

为防止僵尸进程的出现，父进程需要等待子进程结束，这可以通过wait()或waitpid()函数实现。

• wait()：阻塞当前进程，直到一个子进程结束。
• waitpid()：提供更多控制，如非阻塞等待，允许父进程在子进程运行时执行其他任务。

 wait方法

#include<sys/types.h>
#include<sys/wait.h>
pid_t wait(int*status);
返回值：
 成功返回被等待进程pid，失败返回-1。
参数：
 输出型参数，

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。

测试代码：
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
int main( void ){
 pid_t pid;
 if ( (pid=fork()) == -1 )
 perror("fork"),exit(1);
 if ( pid == 0 ){
 sleep(20);
 exit(10);
 } else {
 int st;
 int ret = wait(&st);
 
 if ( ret > 0 && ( st & 0X7F ) == 0 ){ // 正常退出
 printf("child exit code:%d\n", (st>>8)&0XFF);
 } else if( ret > 0 ) { // 异常退出
 printf("sig code : %d\n", st&0X7F );
 }
 }
}测试结果：
 [root@localhost linux]# ./a.out #等20秒退出
 child exit code:10 
 [root@localhost linux]# ./a.out #在其他终端kill掉
 sig code : 9

具体代码实现

 非阻塞等待，等待成功，子进程退出了，父进程回收成pid_t >0,反之pid<0.pid_t==0:检测是成功的，只不过子进程没退出，需要你下一次重复等待。所以我们一般都是 通过 非阻塞等待的时候+循环来确定状态，这个就叫非阻塞轮询。在非阻塞轮询的过程中允许父进程做一些其他的事

 进程的阻塞等待方式:

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(257);
 } else{
 int status = 0;
 pid_t ret = waitpid(-1, &status, 0);//阻塞式等待，等待5S
 printf("this is test for wait\n");
 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;
}
运行结果:
[root@localhost linux]# ./a.out
child is run, pid is : 45110
this is test for wait
wait child 5s success, child return code is :1.

#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;
}

进程程序替换

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

 替换函数

#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[]);

 命名理解

#include <unistd.h>
int main()
{
 char *const argv[] = {"ps", "-ef", NULL};
 char *const envp[] = {"PATH=/bin:/usr/bin", "TERM=console", NULL};
 execl("/bin/ps", "ps", "-ef", NULL);
 // 带p的，可以使用环境变量PATH，无需写全路径
 execlp("ps", "ps", "-ef", NULL);
 // 带e的，需要自己组装环境变量
 execle("ps", "ps", "-ef", NULL, envp);
 execv("/bin/ps", argv);
 
 // 带p的，可以使用环境变量PATH，无需写全路径
 execvp("ps", argv);
 // 带e的，需要自己组装环境变量
 execve("/bin/ps", argv, envp);
 exit(0);
}