• 作者: 雪山肥鱼
• 时间：20210512 06:55
• 目的：进程生命周期，进程的各种状态

# 何为进程
# task_struct的管理
# 进程的生命周期
  ## 僵尸状态
  ## 停止态
  ## 深度睡眠与浅睡眠
# 初见fork

何为进程

task_struckt PCB.png
进程是资源单位。所以进程一定会掌控着一些资源。比如内存，文件，信号等。搞清楚一个进程，就是搞清楚资源。
同时也会包含进程自身的描述，pid等
比如

• *mm 指向内存资源
• *fs root在哪里，当前工作目录在哪里
• *file 打开了哪些文件，这些文件的fd。文件1、2、3是什么
• *signal 信号资源

pid 每进程都会有的 身份证号。
$ cat /proc/sys/kernal/pid_max pid的进程是有限的。

task_struct 的管理

pstree 进程是有父子兄弟关系的

如果使用单一的数据结构去管理进程，有些不妥。

• 比如只用链表，但是进程是由父子关系的，用链表去找一个进程的父进程是很困难的。所以引用树。
• 通过pid去检索进程，比如 kill -2 5430 ，用哈希去检索是非常快的。可以快速的将进程检索出来。

通过不同的数据结构去描述和管理，遍历用链表，知道进程的父就用数，检索进程用哈希表。以空间，换时间

进程的生命周期

1. 就绪与运行的状态标识符一致
2. 处于就绪态的进程，拿到资源就会运行
3. 处于运行态的进程，当时间片用完，或者有级别更高的进程要抢占，则会且回到就绪
4. 不能占着死等资源，要切换到睡眠态。
5. 等到了资源，就从睡眠切换回就绪

进程只要处于就绪状态，只要有CPU资源，就会运行。但linux中的生命周期会有6种状态。但任何一个操作系统，只要有就绪、运行、睡眠这3种，那为什么会有6种呢？

状态解读

进程的6种状态.png

僵尸状态

当一个进程被杀掉，首先会进入僵尸，task_struct 不会消失，但是进程所依附的资源都已经消失。不存在 内存泄漏
僵尸状态留下 的目的，需要通过父进程 的 wait4pid 函数(等待子进程的死亡)，进行回收。
所以僵尸状态是一种非常短暂的状态，死亡，与 被处理掉的 中间状态。已经死了，但还没有来得及回收。

在子进程死亡时，父进程时可以知道子进程的死因的。
如源码中的 wait_task_zombie函数。

static int wait_task_zombie(struct wait_opts * wo, struct task_struct *p )
{
  ...
  if(unlikely(wo -> wo_flags & WNOWAIT)) {
    int exit_code = p->exit_code;
    int why;
    get_task_struct(p);
    read_unlock(&tasklist_lock);
    sched_annotate_sleep();
    if((exit_code & 07f) == 0) {
      why = CLD_EXITED;
      status = exit_code >> 8;
    } else {
      why =(exit_code & 0x80) ? CLD_DUMPED :CLD_KILLED;
      status = exit_code & 0x7f;
    }}}

父进程知道子进程的死因
代码示例：

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

int main(void)
{
    pid_t pid,wait_pid;
    int status;

    pid = fork();

    if (pid==-1)    {
        perror("Cannot create new process");
        exit(1);
    } else  if (pid==0) {
        printf("child process id: %ld\n", (long) getpid());
        pause();
        _exit(0);
    } else {
#if 1 /* define 1 to make child process always a zomie */
        printf("ppid:%d\n", getpid());
        while(1);
#endif
        do {
            wait_pid=waitpid(pid, &status, WUNTRACED | WCONTINUED);

            if (wait_pid == -1) {
                perror("cannot using waitpid function");
                exit(1);
            }

            if (WIFEXITED(status))
                printf("child process exites, status=%d\n", WEXITSTATUS(status));

            if(WIFSIGNALED(status))
                printf("child process is killed by signal %d\n", WTERMSIG(status));

            if (WIFSTOPPED(status))
                printf("child process is stopped by signal %d\n", WSTOPSIG(status));

            if (WIFCONTINUED(status))
                printf("child process resume running....\n");

        } while (!WIFEXITED(status) && !WIFSIGNALED(status));

        exit(0);
    }

如果父进程不回收子进程，子进程会一致处于僵尸状态。
处于僵尸状态的进程是不会被 kill -9 杀掉的，因为已经死了嘛

进程挂的瞬间，内存直接被内核回收，自由落体，直接归0.

停止态

ctrl+z 会让进程stop，fg（占据前台） 在继续
gdb attach debug，会让进程停止

深度睡眠 与 前睡眠

深睡眠与浅睡眠 都是睡眠

• 深睡眠
  必须要等到 资源来了 再醒。信号不会唤醒进程。
  kill -9 都杀不掉。
  僵尸是杀不掉的，但是已经死了
  深度睡眠 外面有一层金钟罩，是活着的，杀不掉的
• 浅睡眠
  资源来了 会醒， 信号来了 也会行。

信号 是 针对进程的 信号打断机制。
原因
程序运行时 发生 page fault，一段代码在硬盘里。
接下来linux要从硬盘把代码段读到内存。
此时linux会将进程置为深度睡眠。不会响应信号。

如果置为浅睡眠，进程相应了信号，如果响应信号的代码依旧在硬盘中，继续发生pagefault，无休止进行下去。没完没了。

如果深度睡眠请求的内容 在NFS 上，此时NFS的硬盘挂了，要想终结这段进程，要么重启电脑了。要么等对方NFS 活了。

初见 fork

main() 
{
  fork();
  printf("hello\n");
  fork();
  printf("hello\n");
  while(1);
}

总共打印 6个 hello。
fork 即 叉子，分裂出一个新生而。根据返回值区分父进程还是子进程。

int main(void)
{
  pid_t pid, wait_pid;
  int status;
  
  pid = fork();
  if(pid == -1) {
    perror("can note create new process");
    exit(1);
  } else if (pid == 0) {
    printf("a\n");
  } else {
    printf("b\n");
  }
  printf("c\n");
  while(1);
}

a 1 次
b 1 次
c 2 次