linux 进程介绍一、进程基本结构二、进程状态切换三、进程退出四、等待进程退出五、僵尸进程六、孤儿进程

62 阅读 0 评论 41 点赞

我是靠谱客的博主腼腆睫毛，最近开发中收集的这篇文章主要介绍linux 进程介绍一、进程基本结构二、进程状态切换三、进程退出四、等待进程退出五、僵尸进程六、孤儿进程，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

文章目录

一、进程基本结构
二、进程状态切换
- 1. 进程状态
- 2. 进程状态切换
三、进程退出
四、等待进程退出
五、僵尸进程
- 1. 避免僵尸进程一
- 2. 避免僵尸进程二
- 3. 避免僵尸进程三
六、孤儿进程

一、进程基本结构

在这里插入图片描述
（1）代码区：加载的是可执行文件代码段，其加载到内存中的位置由加载器完成
（2）全局初始化数据区/静态数据区：存储于数据段（全局初始化，静态初始化数据）的数据的生存周期为整个程序运行过程
（3）未初始化数据区：存储于BSS数据段的数据（全局未初始化，静态未初始化数据）的生存周期为整个程序运行过程
（4）栈区：由编译器自动分配释放，存放函数的参数值、返回值、局部变量等。在程序运行过程中实时加载和释放
（5）堆区：用于动态内存分配。堆在内存中位于BSS区和栈区之间，一般由程序员分配和释放

二、进程状态切换

1. 进程状态

运行状态：获得CPU的进程处于此状态，对应的程序在CPU上运行着
阻塞状态：为了等待某个外部事件的发生（如等待I/O操作的完成，等待另一个进程发来消息），暂时无法运行
就绪状态：具备了一切运行需要的条件，由于其他进程占用CPU而暂时无法运行

2. 进程状态切换

运行状态 ===> 阻塞状态：例如正在运行的进程提出I/O请求，由运行状态转化为阻塞状态
阻塞状态 ===> 就绪状态：例如I/O操作完成之后，由阻塞状态转化为就绪状态
就绪状态 ===> 运行状态：例如就绪状态的进程被进程调度程序选中，分配到CPU中运行，由就绪状态转化为运行状态
运行状态 ===> 就绪状态：处于运行状态的进程的时间片用完，不得不让出CPU，由运行状态转化为就绪状态

三、进程退出

void exit(int value);
void _exit(int value);

两个函数功能和用法是一样的，都是结束调用此函数的进程，只是 exit() 函数会刷新 I/O 缓冲区
在这里插入图片描述

四、等待进程退出

pid_t wait(int *status);
阻塞等待一个子进程结束，如果任意一个子进程结束了，此函数就返回并回收该子进程的资源。若调用进程没有子进程，该函数立即返回；若它的子进程已经结束，函数同样立即返回，并且回收那个早已结束进程的资源
pid_t waitpid(pid_t pid, int *status, int options);
option = 0: 同 wait()，阻塞父进程，等待子进程退出
option = WNOHANG: 非阻塞方式，等待子进程退出

进程退出的时候，内核释放其所有资源、包括打开的文件、占用的内存等。但仍保留一定的信息，主要指进程控制块信息（包括进程号、退出状态、运行时间等）
当一个进程正常或异常终止时，内核就向其父进程发送 SIGCHLD 信号，父进程可以通过 wait() 或 waitpid() 等待子进程结束，获取子进程结束状态，同时回收资源。两个函数的功能一样，区别在于wait() 函数会阻塞，waitpid() 可以设置不阻塞，还可以指定等待哪个子进程结束

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

int main(int argc, char *argv[])
{
    pid_t pid;

    pid = fork();
    if (0 == pid)
    {
        for (int i=0; i<5; i++)
        {
            printf("this is son processn");
            sleep(1);
        }
        exit(2);
    }
    else
    {
        int status = 0;
        
        // 阻塞等待子进程结束，回收子进程的资源
        // exit(2)的2只是保存在status某个字段中，需要用宏定义取出
        wait(&status);
        
        // waitpid(-1, &status, 0);         // 和 wait() 没区别，0：阻塞
        // waitpid(pid, &status, 0);        // 指定等待进程号为 pid 的子进程，0：阻塞
        // waitpid(pid, &status, WNOHANG);  // 指定等待进程号为 pid 的子进程，WNOHANG：不阻塞
        if (WIFEXITED(status) != 0) // 子进程正常终止
        {
            printf("son process return %dn", WEXITSTATUS(status));
        }
        printf("this is father processn");
    }
    return 0;
}

五、僵尸进程

僵尸进程：进程运行结束但占用的资源未被回收
在每个进程退出的时候，如果父进程没有调用 wait() 或 waitpid() 的话，那么保留的那段信息就不会释放，其进程号就会一直被占用，如果大量的产生僵死进程，系统将因为没有可用的进程号而导致不能产生新的进程

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

int main(int argc, char *argv[])
{
    pid_t pid;
    pid = fork();
    if (0 == pid )
    {
        printf("[son process id]: %dn", getpid());
        exit(0);
    }
    else
    {
        sleep(2);
        printf("[father process id]: %dn", getpid());
        // wait(NULL);
        while(1);
    }
    return 0;
}

在这里插入图片描述

1. 避免僵尸进程一

最简单的方法，父进程通过 wait() 和 waitpid() 等函数等待子进程结束，但是这会导致父进程挂起

2. 避免僵尸进程二

如果父进程不关心子进程什么时候结束，那么可以用 signal(SIGCHLD, SIG_IGN) 通知内核，自己对子进程的结束不感兴趣，父进程忽略此信号。那么子进程结束后，内核会直接回收，并不再给父进程发送信号

3. 避免僵尸进程三

如果父进程不能挂起，则通过 signal() 函数添加 SIGCHLD 信号处理回调函数，在其回调函数里调用 wait() 或 waitpid() 回收资源

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

void sig_child(int signo)
{
    pid_t  pid;

    while ((pid = waitpid(-1, NULL, WNOHANG)) > 0)
    {
        printf("child %d terminated.n", pid);
    }
}

int main(int argc, char *argv[])
{
    pid_t pid;

    // signal(SIGCHLD, SIG_IGN);   // 忽略子进程退出信号，当子进程结束后内核直接回收，不再给父进程发送信号
    signal(SIGCHLD, sig_child); // 捕捉子进程退出信号
    pid = fork();
    if (0 == pid )
    {
        printf("[son process id]: %dn", getpid());
        exit(0);
    }
    else
    {
        sleep(2);
        printf("[father process id]: %dn", getpid());
        // wait(NULL);
        while(1);
    }
    return 0;
}

六、孤儿进程

孤儿进程：父进程运行结束但子进程还未运行结束的子进程
进程结束的时候，系统都会扫描当前系统中所运行的所有进程，看有没有哪个进程是刚刚结束的这个进程的子进程，如果是的话就由 init(pid = 1) 进程接管成为他的父进程，由 init 进程对它们完成状态收集和资源回收工作
init 进程循环地 wait() 已经退出的子进程，这样当一个孤儿进程结束了其生命周期的时候，init 进程就会对它们完成状态收集和资源回收工作，因此孤儿进程并不会造成资源泄漏等危害

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

int main()
{
    pid_t  pid;

    pid = fork();
    if (0 == pid)
    {
        sleep(2);
        printf("son proess id = %d, father proess id = %dn", getpid(), getppid());
        exit(0);
    }
    else
    {
        printf("father process, i am exitedn");
        exit(0);
    }
    return 0;
}