【Linux】进程控制

---

---

🎪 进程控制

进程的控制，包括进程创建，进程等待，进程退出等.

🚀1.进程创建

我们之前学过用fork()创建子进程，父进程调用fork()，当控制转移到内核中的fork代码后，fork会做如下工作：

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

当一个进程调用fork之后，就有两个二进制代码相同的进程。而且它们都运行到相同的地方，且fork之前父进程独立执行，fork之后，父子两个执行流分别执行。

注意，fork之后，谁先执行完全由调度器决定。fork也可能调度失败，原因有两个：

• 系统中有太多的进程
• 实际用户的进程数超过了限制

🚀2.写时拷贝

这个之前的博客说过，可以再看下：进程描述与进程优先级

🚀3.进程退出

我们知道进程创建后，无非就是：进程正常运行结束以及进程异常退出

• 进程正常运行结束
  那么结果正确与否我们应该判定呢？ —— 进程退出码

• 进程异常退出
  如果进程接收到一个进程信号比如kil -9而强制退出，换句话说，判断一个进程是否正常运行，就看它是否收到了——进程信号

⭐3.1 进程退出码

我们原来学习C语言的时候为什么最后main函数要返回一个0呢，返回那个0的意义是什么呢？其实return的那个0就是我们当前程序的进程退出码，我们也可以返回其他值作为进程退出码.

命令：echo $?
功能：显示最近进程的进程退出码

先来看一段代码：

#include <stdio.h>

int add(int n)
{
  printf("enter add\n");
  int sum = 0;
  for (int i = 0; i <= n; i++)
  {
    sum += i;
  }
  printf("output add\n");
  return sum;
}
int main()
{
  int result = add(100);

  return 0;//进程退出码
}

因此我们可以用进程退出码来判断代码跑完后的结果是否正确，将上述代码改为：

#include <stdio.h>

int add(int n)
{
  printf("enter add\n");
  int sum = 0;
  for (int i = 0; i < n; i++)
  {
    sum += i;
  }
  printf("output add\n");
  return sum;
}
int main()
{
  int result = add(100);
  if (result == 5050)
  {
    return 0;
  }else{
    return 115;
  }
}

这是可以看到当我们的程序出了问题，相应的进程退出码也发生变化.

官方语言也对不同进程退出码给出了具体进程健康状态的含义，我们可以用strerror(i)函数查看：

#include <stdio.h>
#include <string.h>

int main()
{
  for (int i = 0; i <= 200; i++)
  {
    printf("%d : %s\n", i, strerror(i));
  }
  return 0;
}

规定：进程退出码的范围是0-255

⭐3.2 进程信号

我们可以用kill -l查看进程信号列表：

后续我们会对进程信号作更详细的了解

⭐3.3 进程退出方法

进程退出方法有main执行流返回，还有exit()和_exit()主动退出. return直接返回我们已经谈过，接下来说说这两个函数：

exit(code)：

exit函数可以直接退出当前进程，里面的参数就是进程退出码：

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

int main()
{
  printf("hello world");
  sleep(1);
  exit(112);
  return 0;
}

我们观察到，hello world在休眠两秒后打印出来，其实这就是缓冲区的刷新

_exit(code):

同样一份代码，把exit函数替换成_exit函数观察效果：

我们发现，_exit函数不会刷新缓冲区，当使用该函数进程退出后缓冲区不会刷新

需要注意的是，exit最后也会调用_exit, 但在调用_exit之前，还做了其他工作：

1. 执行用户通过at_exit或on_exit定义的清理函数。
2. 关闭所有打开的流，所有的缓存数据均被写入
3. 调用_exit

需要注意的是，缓冲区位置在内核管理的内存中

🚀 4.进程等待

为什么会存在进程等待呢？

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

总之就是，父进程通过进程等待的方式，回收子进程资源，获取子进程退出信息，同时也避免了内存泄露

⭐4.1 进程等待含义

进程等待就是父进程通过系统调用，获取子进程退出码或者退出信号的方式，顺便释放子进程占用的资源

⭐4.2 进程等待方法

我们可以通过wait()方法和waitpid()方法来父进程进行进程等待，这两个函数头文件是<sys/types.h>和<sys/wait.h>

1.wait

pid_t wait(int* status)

wait函数内参数是进程状态——进程退出码 + 进程信号，具体留到waitpid方法再说明，返回值>0，则表示子进程pid，否则返回-1.

阻塞等待：pro4.c

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/types.h>
#include <stdlib.h>
#include <string.h>

int main()
{
  pid_t id = fork();

  if (id == 0)
  {
    //子进程
    int cnt = 5;
    while (cnt)
    {
      printf("I am child process. I have %d seconds to exit. pid:%d  ppid:%d\n", cnt--, getpid(), getppid());
      sleep(1);
    }
    if (1) exit(111);
    exit(0);
  }
 
  //父进程
  sleep(10);
  pid_t ret_id = wait(NULL);
  if (ret_id > 0)
  {
  printf("I am father process. Wait for sucess! pid:%d  ppid:%d\n", getpid(), getppid());
  }
  sleep(5);
  return 0;
}

这里我们再输入一行命令行脚本以便于更好的观察父子进程状态：

while : ; do ps axj | head -1 && ps ajx | grep pro4 | grep -v grep; sleep 1;echo "--------------";  done

我们发现父子进程初始S态(因为需要请求显示器资源，本质上应该是R和S态交替运行)，当通过exit函数退出子进程后，子进程就进入僵尸状态Z，然后父进程执行wait函数回收子进程资源，以及获取子进程状态，最后回收成功。

2.waitpid

这个方法相对于wait来说更好用.

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

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

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

关于第二个参数，其实就是进程状态status，而进程状态 = 进程退出码 + 进程信号，可是我们的int status只有4个字节，32个比特位，怎么存放下两个数据呢？答案是——位图，所谓位图，就是用每一位来存放某种状态，适用于海量数据，数据无重复的场景，通常是用来判断某个数据存不存在的。我们的Linux权限就是用位图来表示的.所以，我们可以用位图的四个字节来分别表示进程退出码和进程信号，如下：

我们用32bit为的后15位表示进程状态，用低7位来表示进程信号，用高8位来表示进程退出码

那么子进程不同状态下，父进程调用wait函数时父进程又处于怎样的状态呢？

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

那么如果子进程一直运行，父进程是不是就会一直处于阻塞状态，那么如果想让父进程循环者等待呢？这时就要看我们waitpid的第三个参数了，该参数可以控制父进程是否是阻塞等待还是非阻塞轮询

非阻塞轮询：pro5.c

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>


int main()
{
    pid_t id = fork();
    if(id == 0)
    {
        //子进程
        int cnt = 5;
        while(cnt)
        {
            printf("I  am child process. I have %d seconds to exit. pid: %d, ppid: %d\n", cnt--, getpid(), getppid());
            sleep(1);
            int* p = NULL;
            *p = 100;
        }
        if(1) exit(114);
    }
    // 父进程
    while(1)
    {
        int status = 0;
        pid_t ret_id = waitpid(id, &status, WNOHANG); // 夯住了
        if(ret_id < 0)
        {
            printf("waitpid error!\n");
            exit(1);
        }
        else if(ret_id == 0)
        {
            printf("I am father process, I have other to do....\n");
            sleep(1);
            continue;
        }
        else{
            printf("I am father process. Wait sucess!!! pid: %d, ppid: %d, ret_id: %d, child exit code: %d, child exit signal: %d\n",\
                getpid(), getppid(), ret_id, (status>>8)&0xFF, status & 0x7F);
            break;
        }
    }
}

我们用(status>>8)&0xFF可以拿到进程退出码，用status&0x7F可以拿到进程信号