Linux中进程 - 技术栈

一、认识进程

进程(PCB)=内核数据结构(task_struct)+程序的代码和数据

每一个进程都有其独立的task_struct,OS对众多的task_struct进行管理，如何管理？先描述再组织，所有运⾏在系统⾥的进程都以task_struct链表的形式存在内核⾥，而且是双向链表

我们也可以通过ps指令来显示当前终端下由当前用户启动的进程信息

二、创建进程

系统调用fork()可以创建进程，有两个返回值，如果返回值等于0，那么为子进程，如果返回值大于0，那么就是父进程，如果返回值小于0 ，那么创建进程失败。所创建的进程是当前进程的子进程，⽗⼦进程代码共享，数据各⾃开辟空间，私有⼀份（采⽤写时拷⻉），两者数据互不干涉

代码示例：

cpp 复制代码

#include<iostream>
#include<unistd.h>
#include<sys/types.h>
using namespace std;
int main()
{
    int ret=fork();
    if(ret<0)
    {
        exit(1);
    }
    //返回值等于0，是子进程
    if(ret==0)
    {
        pid_t pid=getpid();
        pid_t ppid= getppid();
        cout<<"我是子进程，我的pid是："<<" "<<pid<<"我的父进程是："<<ppid<<endl;
    }
    //返回值大于0，是父进程
    else
    {
        pid_t pid=getpid();
        cout<<"我是父进程，我的pid是："<<pid<<endl;
    }
    return 0;
}

三、验证父子进程的独立性(写实拷贝)

进程间有独立性，哪怕是父子进程也不例外，子进程的资源从父进程获得，但是获得后子进程的数据通过写实拷贝拥有了独立性。

代码验证：

cpp 复制代码

#include<iostream>
#include<unistd.h>
#include<sys/types.h>
using namespace std;
int main()
{
    int ret=fork();
    int count=100;
    if(ret<0)
    {
        exit(1);
    }
    //返回值等于0，是子进程
    if(ret==0)
    {
        pid_t pid=getpid();
        pid_t ppid= getppid();
        while(1)
        {
            cout<<"我是子进程，我的pid是："<<" "<<pid<<"我的父进程是："<<ppid<<"count的值为："<<count<<endl;
            count++;
            sleep(4);
        }
        

    }
    //返回值大于0，是父进程
    else
    {
        pid_t pid=getpid();
        while(1)
        {
            cout<<"我是父进程，我的pid是："<<pid<<"count的值为："<<count<<endl;
            count--;
            sleep(2);
        }
        
    }
    return 0;
}

可以观察到，相同的变量count，在子进程里面是递增的，在父进程里面是递减的。

四、进程的常见状态

监测S状态

再次运行上方创建子进程的代码，通过命令监测可以看到，父进程和子进程都是S状态，而不是R状态，因为有了IO，IO执行的时间太快了，剩下的时间都是在等待状态S，所以我们就无法监测到R状态，想要监测到R状态，只要把IO设备取消就好，如没有输入输出函数的死循环

监测R状态

僵尸进程

所有的进程都是某个进程的子进程，所创建的子进程都是拿来执行某个任务的，任务完成的怎么样，完成的相关信息父进程是需要知道的。

一个子进程在死亡到被抬走之间的时间，子进程的状态就是僵尸状态Z，目的就是为例让父进程获取子进程的退出信息。如果子进程退出，父进程不回收，不获取子进程的退出信息，那么子进程的task_struck会一直存在，就类似与C语言中的结构体，一直占用空间，那么就会造成内存泄露。

孤儿进程

如果父进程退出了，子进程没退出，子进程还在运行，那么子进程就是个孤儿进程。子进程被OS领养，也就是被进程1领养。父进程库随意退，因为父进程的父进程是bash

五、进程终止

进程的正常终止有三种：main返回，exit，_exit。

我们可以通过echo $?查看退出码，以获得最后⼀次执⾏的命令的状态。

exit与_exit

两者都用于终止进程，并设置退出码，但是exit终止进程前会对 I/O 缓冲区被刷新，并且会执行注册的终止处理函数，保证程序的资源得到正确释放和清理。而_exit不会调用任何注册的终止处理函数，它会直接终止进程，绕过这些清理操作。

使用exit():

cpp 复制代码

#include<iostream>
using namespace std;

int main()
{
    cout<<"helloworld";
    exit(1);
    return 0;
}

使用_exit()

cpp 复制代码

#include<iostream>
#include<unistd.h>
using namespace std;

int main()
{
    cout<<"helloworld";
    _exit(0);
    return 0;
}

wait与waitpid

如果子进程退出，父进程没有回收，那么就会进入僵尸，那么kill -9 也没办法，所以父进程等待子进程是有必要的

wait 函数会让调用它的进程阻塞，直至其任意一个子进程终止。之后，它会获取子进程的终止状态，并将其存储于 status 所指向的内存位置。如果不在意子进程的终止信息，那么可以设置status为null。

cpp 复制代码

#include<iostream>
#include <sys/types.h>
#include <sys/wait.h>
#include<unistd.h>
using namespace std;

int main()
{
    pid_t id=fork();
    if(id==0)
    {
        sleep(10);
        cout<<"我是子进程"<<endl;
    }
    else{
        wait(nullptr);
        cout<<"我是父进程，已经回收子进程完毕"<<endl;
    }
    return 0;
}

上面的代码，子进程完成cout后被父进程回收，才执行父进程的cout

waitpid 函数比 wait 函数更灵活，它能让你指定要等待的子进程。

cpp 复制代码

#include<iostream>
#include <sys/types.h>
#include <sys/wait.h>
#include<unistd.h>
using namespace std;

int main()
{
    pid_t id=fork();
    if(id==0)
    {
        cout<<"我是子进程"<<endl;
        sleep(10);
    }
    else{
        // wait(nullptr);
        waitpid(id,nullptr,0);//0表示阻塞等待
        cout<<"我是父进程，已经回收子进程完毕"<<endl;
    }
    return 0;
}