2022-06-06

字数统计: 5.8k字 | 阅读时长: 23分

Linux服务器项目-3

Linux多进程开发：

2.1进程概述

程序是包含一系列信息的文件，这些信息描述了如何在运行时创建一个进程：这些信息又包括二进制格式标识，机器语言指令，程序入口地址，数据，符号表及重定位表，共享库和动态链接信息，其他信息。

进程是正在运行的程序的实例。是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。

可以用一个程序来创建多个进程，进程是由内核定义的抽象实体，并为该实体分配用以执行程序的各项系统资源。从内核的角度看，进程由用户内存空间和一系列内核数据结构组成。

单道程序：计算机内存只能运行一个程序。
多道程序：计算机内存可以存放几个相互独立的程序，它们之间穿插运行。对于一个单 CPU 系统来说，==程序同时处于运行状态只是一种宏观上的概念==，他们虽然都已经开始运行，但就微观而言，任意时刻， CPU 上运行的程序只有一个。

2.1.1 时间片：又称为“量子 (quantum) ”或“处理器片 processor slice
是操作系统分配给每个正在运行的进程微观上的一段 CPU 时间。时间片太短或太长都会使CPU利用率下降。

时间片由操作系统内核的调度程序分配给每个进程。首先，内核会给每个进程分配相等的初始时间片，然后每个进程轮番地执行相应的时间，当所有进程都处于时间片耗尽的状态时，内核会重新为每个进程计算并分配时间片，如此往复。

2.1.2 并行和并发：

并行 ( parallel)：指在同一时刻，有多条指令在多个处理器上同时执行。
并发 ( concurrency)：指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。

2.1.3 进程控制块(PCB)：

为了管理进程，内核必须对每个进程所做的事情进行清楚的描述。内核为每个进程分配一个 PCB(Processing Control Block) 进程控制块，维护进程相关的信息。Linux 内核的进程控制块是 task_struct 结构体。

其内部的成员函数有很多，需要主要掌握的有：

进程 id ：系统中每个进程有唯一的 id ，用 pid_t 类型表示，其实就是一个非负整数
进程的状态：有就绪、运行、挂起、停止等状态
进程切换时需要保存和恢复的一些 CPU 寄存器
描述虚拟地址空间的信息
描述控制终端的信息
当前工作目录 (Current Working Directory)
umask 掩码
文件描述符表，包含很多指向 file 结构体的指针
和信号相关的信息
用户 id 和组 id
会话（ Session ）和进程组
进程可以使用的资源上限（Resource Limit）

ulimit -a命令可以显示当前系统资源的上限

2.2 进程状态转换

进程状态反映进程执行过程的变化。这些状态随着进程的执行和外界条件的变化而转换。在三态模型中，进程状态分为三个基本状态，即就绪态，运行态，阻塞态。在五态模型中，进程分为新建态、就绪态，运行态，阻塞态，终止态。

运行态：进程占有处理器正在运行
就绪态：进程具备运行条件，等待系统分配处理器以便运行。当进程已分配到除 CPU 以外的所有必要资源后，只要再获得 CPU ，便可立即执行。在一个系统中处于就绪状态的进程可能有多个，通常将它们排成一个队列，称为就绪队列
阻塞态：又称为等待态或睡眠态，指进程不具备运行条件，正在等待某个事件的完成
新建态：进程刚被创建时的状态，尚未进入就绪队列
终止态：进程完成任务到达正常结束点，或出现无法克服的错误而异常终止，或被操作系统及有终止权的进程所终止时所处的状态。进入终止态的进程以后不再执行，但依然保留在操作系统中等待善后。一旦其他进程完成了对终止态进程的信息抽取之后，操作系统将删除该进程。

查看进程：ps aux / ajx，通过tty指令可以查看当前终端

a：显示终端上的所有进程，包括其他用户的进程
u：显示进程的详细信息
x：显示没有控制终端的进程
j：列出与作业控制相关的信息

输出了以下的信息：

#用户   进程ID  CPU占有率  内存占有率         当前所属终端   进程状态     ps aux
  USER   PID     %CPU      %MEM    VSZ   RSS  TTY        STAT     START TIME COMMAND
#父进程的ID    进程组的ID 会话ID   ps ajx
  PPID    PID   PGID     SID    TTY   TPGID STAT   UID   TIME  COMMAND

实时显示进程状态，top命令：可以在使用top 命令时加上 d 来指定显示信息更新的时间间隔，在 top 命令执行后，可以按以下按键对显示的结果进行排序：

M 根据内存使用量排序
P 根据 CPU 占有率排序
T 根据进程运行时间长短排序
U 根据用户名来筛选进程
K 输入指定的 PID 杀死进程

杀死进程，kill命令：

kill [signal] pid
kill -l 列出所有信号
kill -SIGKILL 进程 ID（sigkill是序号为9的一个宏）
kill -9 进程 ID
killall name 根据进程名杀死进程

进程号和相关函数：

每个进程都由进程号来标识，其类型为 pid_t （整型），进程号的范围 0 ~ 32767 。进程号总是唯一的，但可以重用。当一个进程终止后，其进程号就可以再次使用。

任何进程（除 init 进程）都是由另一个进程创建，该进程称为被创建进程的父进程，对应的进程号称为父进程号（PPID）。

进程组是一个或多个进程的集合。他们之间相互关联，进程组可以接收同一终端的各种信号，关联的进程有一个进程组号（ PGID ）。默认情况下，当前的进程号会当做当前的进程组号。

相关的函数：

进程号和进程组相关函数：
pid_t getpid(void);
pid_t getppid(void);
pid_t getpgid(pid_t pid);

2.3 创建进程

系统允许一个进程创建一个新进程，新进程即为子进程，子进程还可以创建新的子进程，形成树形结构。

pid_t fork(void);通过fork创建子进程，fork返回值一个在父进程中，一个在子进程中。

子进程相当于对父进程进行了复制，其代码部分都是一样的，但是fork函数会返回不同的PID号，这样可以将父进程和子进程区分开。两者之间互不影响，比如修改父进程中的一个元素的值不能影响子进程。采用读时复制，写时共享的机制，为了节约内存的使用，降低拷贝内存需要的时间。子进程结束后，父进程要回收其资源

Linux 进程共享（读时共享写时复制）是什么_年年年年年的博客-CSDN博客_读时共享

/*
    #include <sys/types.h>
    #include <unistd.h>

    pid_t fork(void);
        函数的作用：用于创建子进程。
        返回值：
            fork()的返回值会返回两次。一次是在父进程中，一次是在子进程中。
            在父进程中返回创建的子进程的ID,
            在子进程中返回0
            如何区分父进程和子进程：通过fork的返回值。
            在父进程中返回-1，表示创建子进程失败，并且设置errno

        父子进程之间的关系：
        区别：
            1.fork()函数的返回值不同
                父进程中: >0 返回的子进程的ID
                子进程中: =0
            2.pcb中的一些数据
                当前的进程的id pid
                当前的进程的父进程的id ppid
                信号集

        共同点：
            某些状态下：子进程刚被创建出来，还没有执行任何的写数据的操作
                - 用户区的数据
                - 文件描述符表
        
        父子进程对变量是不是共享的？
            - 刚开始的时候，是一样的，共享的。如果修改了数据，不共享了。
            - 读时共享（子进程被创建，两个进程没有做任何的写的操作），写时拷贝。
        
*/

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

int main() {

    int num = 10;

    // 创建子进程
    pid_t pid = fork();

    // 判断是父进程还是子进程
    if(pid > 0) {
        // printf("pid : %d\n", pid);
        // 如果大于0，返回的是创建的子进程的进程号，当前是父进程
        printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid());

        printf("parent num : %d\n", num);
        num += 10;
        printf("parent num += 10 : %d\n", num); //输出20


    } else if(pid == 0) {
        // 当前是子进程
        printf("i am child process, pid : %d, ppid : %d\n", getpid(),getppid());
       
        printf("child num : %d\n", num);
        num += 100;
        printf("child num += 100 : %d\n", num); //输出110，父进程和子进程之间互不影响
    }

    // for循环
    for(int i = 0; i < 3; i++) {
        printf("i : %d , pid : %d\n", i , getpid());
        sleep(1);
    }

    return 0;
}

/*
实际上，更准确来说，Linux 的 fork() 使用是通过写时拷贝 (copy-on-write) 实现。
写时拷贝是一种可以推迟甚至避免拷贝数据的技术。
内核此时并不复制整个进程的地址空间，而是让父子进程共享同一个地址空间。
只用在需要写入的时候才会复制地址空间，从而使各个进程拥有各自的地址空间。
也就是说，资源的复制是在需要写入的时候才会进行，在此之前，只有以只读方式共享。
注意：fork之后父子进程共享文件，
fork产生的子进程与父进程相同的文件文件描述符指向相同的文件表，引用计数增加，共享文件偏移指针。
*/

GDB多进程调试：

GDB只能追踪一个进程，默认追踪父进程。

设置调试父进程或者子进程：set follow-fork-mode [parent （默认）|child]，通过show follow-fork-mode 可以查看调试的是父进程还是子进程

设置调试模式：set detach-on-fork [on | off]；默认为on ，表示调试当前进程的时候，其它的进程继续运行，如果为 off ，调试当前进程的时候，其它进程被 GDB 挂起。

查看调试的进程：info inferiors
切换当前调试的进程：inferior id
使进程脱离GDB 调试： detach inferiors id，程序就会继续向下执行。

测试程序：

#include <stdio.h>
#include <unistd.h>
int main() {
    printf("begin\n");
    if(fork() > 0) {
        printf("我是父进程：pid = %d, ppid = %d\n", getpid(), getppid());
        int i;
        for(i = 0; i < 10; i++) {
            printf("i = %d\n", i);
            sleep(1);
        }
    } else {
        printf("我是子进程：pid = %d, ppid = %d\n", getpid(), getppid());
        int j;
        for(j = 0; j < 10; j++) {
            printf("j = %d\n", j);
            sleep(1);
        }
    }
    return 0;
}

2.4 exec函数族

类似于C++中的函数重载，exec 函数族的作用是根据指定的文件名找到可执行文件，并用它来取代调用进程的内容，换句话说，就是在调用进程内部执行一个可执行文件。exec 函数族的函数执行成功后不会返回，而会继续向下执行，执行失败会返回-1.

//C库中的函数，execl, execlp用的最多
int execl(const char *path, const char *arg, .../* (char *) NULL */);
int execlp(const char *file, const char *arg, ... /* (char *) NULL */);
int execle(const char *path, const char *arg, .../*, (char *) NULL, char * const envp[] */);
int execv(const char *path, char *const argv[]);
int execvp(const char *file, char *const argv[]);
int execvpe(const char *file, char *const argv[], char *const envp[]);
//linux系统函数
int execve(const char *filename, char *const argv[], char *const envp[]);
//l(list)参数地址列表，以空指针结尾
//v(vector)存有各参数地址的指针数组的地址
//p(path)按 PATH 环境变量指定的目录搜索可执行文件
//e(environment)存有环境变量字符串地址的指针数组的地址

执行exec函数族中的函数就不会再执行进程中的其他内容了。

execl函数：

/*  
    #include <unistd.h>
    int execl(const char *path, const char *arg, ...);
        - 参数：
            - path:需要指定的执行的文件的路径或者名称
                a.out /home/nowcoder/a.out 推荐使用绝对路径
                ./a.out hello world

            - arg:是执行可执行文件所需要的参数列表
                第一个参数一般没有什么作用，为了方便，一般写的是执行的程序的名称
                从第二个参数开始往后，就是程序执行所需要的的参数列表。
                参数最后需要以NULL结束（哨兵）

        - 返回值：
            只有当调用失败，才会有返回值，返回-1，并且设置errno
            如果调用成功，没有返回值。

*/
#include <unistd.h>
#include <stdio.h>
int main() {
    // 创建一个子进程，在子进程中执行exec函数族中的函数
    pid_t pid = fork();
    if(pid > 0) {
        // 父进程
        printf("i am parent process, pid : %d\n",getpid());
        sleep(1); //没有这句话会产生孤儿进程
    }else if(pid == 0) {
        // 子进程
        // execl("hello","hello",NULL);

        execl("/bin/ps", "ps", "aux", NULL); //只会执行hello进程
        perror("execl");
        printf("i am child process, pid : %d\n", getpid());
    }
    for(int i = 0; i < 3; i++) {
        printf("i = %d, pid = %d\n", i, getpid());
    }
    return 0;
}

execlp函数：

/*  
    #include <unistd.h>
    int execlp(const char *file, const char *arg, ... );
        - 会到环境变量中查找指定的可执行文件，如果找到了就执行，找不到就执行不成功。通过env可以查看环境变量
        - 参数：
            - file:需要执行的可执行文件的文件名
                a.out
                ps

            - arg:是执行可执行文件所需要的参数列表
                第一个参数一般没有什么作用，为了方便，一般写的是执行的程序的名称
                从第二个参数开始往后，就是程序执行所需要的的参数列表。
                参数最后需要以NULL结束（哨兵）

        - 返回值：
            只有当调用失败，才会有返回值，返回-1，并且设置errno
            如果调用成功，没有返回值。

        int execv(const char *path, char *const argv[]);
        argv是需要的参数的一个字符串数组
        char * argv[] = {"ps", "aux", NULL};
        execv("/bin/ps", argv);

        int execve(const char *filename, char *const argv[], char *const envp[]);
        char * envp[] = {"/home/nowcoder", "/home/bbb", "/home/aaa"};
*/
#include <unistd.h>
#include <stdio.h>
int main() {
    // 创建一个子进程，在子进程中执行exec函数族中的函数
    pid_t pid = fork();
    if(pid > 0) {
        // 父进程
        printf("i am parent process, pid : %d\n",getpid());
        sleep(1);
    }else if(pid == 0) {
        // 子进程
        execlp("ps", "ps", "aux", NULL);//不需要写路径
        printf("i am child process, pid : %d\n", getpid());
    }
    for(int i = 0; i < 3; i++) {
        printf("i = %d, pid = %d\n", i, getpid());
    }
    return 0;
}

2.5 进程退出，孤儿进程，僵尸进程

进程退出：

#include <stdlib.h>
void exit(int status); //标准C库中, exit实际上调用了_exit,这个函数刷新缓冲区，及换行也能输出
#include <unistd.h>
void _exit(int status); //linux系统函数，不能输出换行

实际上我们写程序常用的return 0也是代表程序退出，这点与exit()函数是相同的。

/*
    #include <stdlib.h>
    void exit(int status);

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

    status参数：是进程退出时的一个状态信息。父进程回收子进程资源的时候可以获取到。
*/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main() {

    printf("hello\n");
    printf("world");

    // exit(0); //打印结果有world，其能自动刷新缓冲区
    _exit(0);   //结果无world
    
    return 0;
}

孤儿进程：父进程运行结束，但子进程还在运行（未运行结束），这样的子进程就称为孤儿进程（Orphan Process ）每当出现一个孤儿进程的时候，内核就把孤儿进程的父进程设置为 init，也就是pid为1的进程，而 init
进程会循环地 wait() 它的已经退出的子进程。子进程结束后，init进程回收子进程的资源。

#include <sys/types.h>
#include <unistd.h>
#include <stdio.h>
int main() {
    // 创建子进程
    pid_t pid = fork();
    // 判断是父进程还是子进程
    if(pid > 0) {
        printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid());
    } else if(pid == 0) {
        sleep(1);
        // 当前是子进程
        printf("i am child process, pid : %d, ppid : %d\n", getpid(),getppid());
    }
    // for循环
    for(int i = 0; i < 3; i++) {
        printf("i : %d , pid : %d\n", i , getpid());
    }
    return 0;
}

僵尸进程：每个进程结束之后 , 都会释放自己地址空间中的用户区数据，内核区的 PCB 没有办法自己释放掉，需要父进程去释放。进程终止时，父进程尚未回收，子进程残留资源（ PCB ）存放于内核中，变成僵尸进程。

僵尸进程不能被 kill 9 杀死，这样就会导致一个问题，如果父进程不调用wait()或 waitpid() 的话，那么保留的那段信息就不会释放，其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生僵尸进程，将因为没有可用的进程号而导致系统不能产生新的进程，此即为僵尸进程的危害，应当避免。实际上就是父进程一直运行，子进程运行完了。

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

int main() {
    // 创建子进程
    pid_t pid = fork();
    // 判断是父进程还是子进程
    if(pid > 0) {
        while(1) {
            printf("i am parent process, pid : %d, ppid : %d\n", getpid(), getppid());
            sleep(1);
        }
    } else if(pid == 0) {
        // 当前是子进程
        printf("i am child process, pid : %d, ppid : %d\n", getpid(),getppid());
       
    }
    // for循环
    for(int i = 0; i < 3; i++) {
        printf("i : %d , pid : %d\n", i , getpid());
    }
    return 0;
}

wait 和 waitpid 函数

父进程可以通过调用 wait 或 waitpid 得到它的退出状态同时彻底清除掉这个进程，回收子进程的资源。

wait() 和 waitpid() 函数的功能一样，区别在于， wait() 函数会阻塞，waitpid() 可以设置不阻塞， waitpid() 还可以指定等待哪个子进程结束。一个函数只能回收一个子进程。实际上就是让父进程先别运行了，先停停，先阻塞一下把子进程都回收完了自己再运行把！

wait()函数的使用：

/*
    #include <sys/types.h>
    #include <sys/wait.h>
    pid_t wait(int *wstatus);
        功能：等待任意一个子进程结束，如果任意一个子进程结束了，次函数会回收子进程的资源。
        参数：int *wstatus
            进程退出时的状态信息，传入的是一个int类型的地址，传出参数。
        返回值：
            - 成功：返回被回收的子进程的id
            - 失败：-1 (所有的子进程都结束，调用函数失败)

    调用wait函数的进程会被挂起（阻塞），直到它的一个子进程退出或者收到一个不能被忽略的信号时才被唤醒（相当于继续往下执行）
    如果没有子进程了，函数立刻返回，返回-1；如果子进程都已经结束了，也会立即返回，返回-1.

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

int main() {

    // 有一个父进程，创建5个子进程（兄弟）
    pid_t pid;

    // 创建5个子进程
    for(int i = 0; i < 5; i++) {
        pid = fork();
        if(pid == 0) { //如果是子进程，就不会新fork一个进程
            break;
        }
    }

    if(pid > 0) {
        // 父进程
        while(1) {
            printf("parent, pid = %d\n", getpid());

            // int ret = wait(NULL);
            int st;
            int ret = wait(&st); //子进程一直在运行，父进程就阻塞了

            if(ret == -1) { //如果子进程都运行完，返回-1
                break;
            }

            if(WIFEXITED(st)) {
                // 是不是正常退出
                printf("退出的状态码：%d\n", WEXITSTATUS(st));//获取进程退出的状态
            }
            if(WIFSIGNALED(st)) {
                // 是不是异常终止
                printf("被哪个信号干掉了：%d\n", WTERMSIG(st));//获取使进程终止的信号编号
            }

            printf("child die, pid = %d\n", ret); //打印出回收的子进程的ID

            sleep(1);
        }

    } else if (pid == 0){
        // 子进程
         while(1) {
            printf("child, pid = %d\n",getpid());    
            sleep(1);       
         }

        exit(0);
    }

    return 0; // exit(0)
}

waitpid()函数的使用：

默认的进程组的ID就是父进程的ID。

/*
    #include <sys/types.h>
    #include <sys/wait.h>
    pid_t waitpid(pid_t pid, int *wstatus, int options);
        功能：回收指定进程号的子进程，可以设置是否阻塞。
        参数：
            - pid:
                pid > 0 : 某个子进程的pid
                pid = 0 : 回收当前进程组的所有子进程    
                pid = -1 : 回收所有的子进程，相当于 wait()  （最常用）
                pid < -1 : pid的绝对值对应某个进程组的组id，回收指定进程组中的子进程
            - options：设置阻塞或者非阻塞
                0 : 阻塞
                WNOHANG : 非阻塞
            - 返回值：
                > 0 : 返回子进程的id
                = 0 : options=WNOHANG, 表示还有子进程活着
                = -1 ：错误，或者没有子进程了
*/
#include <sys/types.h>
#include <sys/wait.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

int main() {

    // 有一个父进程，创建5个子进程（兄弟）
    pid_t pid;
    // 创建5个子进程
    for(int i = 0; i < 5; i++) {
        pid = fork();
        if(pid == 0) {
            break;
        }
    }

    if(pid > 0) {
        // 父进程
        while(1) {
            printf("parent, pid = %d\n", getpid());
            sleep(1);

            int st;
            // int ret = waitpid(-1, &st, 0);
            int ret = waitpid(-1, &st, WNOHANG);

            if(ret == -1) {
                break;
            } else if(ret == 0) {
                // 说明还有子进程存在
                continue;
            } else if(ret > 0) {

                if(WIFEXITED(st)) {
                    // 是不是正常退出
                    printf("退出的状态码：%d\n", WEXITSTATUS(st));
                }
                if(WIFSIGNALED(st)) {
                    // 是不是异常终止
                    printf("被哪个信号干掉了：%d\n", WTERMSIG(st));
                }

                printf("child die, pid = %d\n", ret);
            }
           
        }
    } else if (pid == 0){
        // 子进程
         while(1) {
            printf("child, pid = %d\n",getpid());    
            sleep(1);       
         }
        exit(0);
    }
    return 0; 
}