第二章 Linux多进程开发（1）

2.1 进程概述

01程序和进程

程序是包含一系列信息的文件，这些信息描述了如何在运行时创建一个进程：

• 二进制格式标识: 每个程序文件都包含用于描述可执行文件格式的元信息。内核利用此信息来解释文件中的其他信息。 (ELE可执行连接格式)
• 机器语言指令:对程序算法进行编码。
• 程序入口地址: 标识程序开始执行时的起始指令位置
• 数据: 程序文件包含的变量初始值和程序使用的字面量值 (比如字符串)
• 符号表及重定位表:描述程序中函数和变量的位置及名称。这些表格有多重用途，其中包括调试和运行时的符号解析(动态链接)
• 共享库和动态链接信息: 程序文件所包含的一些字段，列出了程序运行时需要使用的共享库，以及加载共享库的动态连接器的路径名。
• 其他信息: 程序文件还包含许多其他信息，用以描述如何创建进程
• 进程是正在运行的程序的实例。是一个具有一定独立功能的程序关于某个数据集合的一次运行活动。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。
• 可以用一个程序来创建多个进程，进程是由内核定义的抽象实体，并为该实体分配用以执行程序的各项系统资源。从内核的角度看，进程由用户内存空间和一系列内核数据结构组成，其中用户内存空间包含了程序代码及代码所使用的变量，而内核数据结构则用于维护进程状态信息。记录在内核数据结构中的信息包括许多与进程相关的标识号 (IDs)、虚拟内存表、打开文件的描述符表、信号传递及处理的有关信息、进程资源使用及限制、当前工作目录和大量的其他信息。

02单道、多道程序设计

• 单道程序，即在计算机内存中只允许一个的程序运行
• 多道程序设计技术是在计算机内存中同时存放几道相互独立的程序，使它们在管理程序控制下，相互穿插运行，两个或两个以上程序在计算机系统中同处于开始到结束之间的状态，这些程序共享计算机系统资源。引入多道程序设计技术的根本目的是为了提高CPU的利用率
• 对于一个单 CPU 系统来说，程序同时处于运行状态只是一种宏观上的概念，他们虽然都已经开始运行，但就微观而言，任意时刻，CPU 上运行的程序只有一个
• 在多道程序设计模型中，多个进程轮流使用 CPU。而当下常见 CPU 为纳秒级，1秒可以执行大约 10亿条指令。由于人眼的反应速度是毫秒级，所以看似同时在运行

03 时间片

• 时间片 (timeslice) 又称为“量子 (quantum)”或“处理器片 (processor slice是操作系统分配给每个正在运行的进程微观上的一段 CPU 时间。事实上，虽然一台计算机通常可能有多个 CPU，旦是同一个 CPU 永远不可能真正地同时运行多个任务。在只考虑一个 CPU 的情况下，这些进程“看起来像”同时运行的，实则是轮番穿插地运行由于时间片通常很短(在 Linux 上为 5ms-800ms)，用户不会感觉到。
• 时间片由操作系统内核的调度程序分配给每个进程。首先，内核会给每个进程分配相等的初始时间片，然后每个进程轮番地执行相应的时间，当所有进程都处于时间片耗尽的状态时，内核会重新为每个进程计算并分配时间片，如此往复。

04 并行和并发

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

• 并发是两个队列交替使用一台咖啡机
• 并行是两个队列同时使用两台咖啡机

05 进程控制块（PCB）

• 为了管理进程，内核必须对每个进程所做的事情进行清楚的描述。内核为每个进程分配一入PCB(Processing Control Block)进程控制块，维护进程相关的信息Linux 内核的进程控制块是 task struct 结构体
• 在 /usr/src/linux-headers-xxx/include/linux/sched.h 文件中可以查看 struct task_struct 结构体定义。其内部成员有很多，我们只需要掌握以下部分即可:
  • 进程id:系统中每个进程有唯一的 id，用 pid_t类型表示，其实就是一个非负整数
  • 进程的状态:有就绪、运行、挂起、停止等状态
  • 进程切换时需要保存和恢复的一些CPU寄存器
  • 描述虚拟地址空间的信息
  • 描述控制终端的信息
  • 当前工作目录 (Current Working Directory)
  • umask 掩码
  • 文件描述符表，包含很多指向rile 结构体的指针
  • 和信号相关的信息
  • 用户 id 和组 id
  • 会话 (Session)和进程组
  • 进程可以使用的资源上限 (Resource Limit)

2.2 进程状态转换

01 进程的状态

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

1. 运行态: 进程占有处理器正在运行
2. 就绪态: 进程具备运行条件，等待系统分配处理器以便运行。当进程已分配到除CPU以外的所有必要资源后，只要再获得CPU，便可立即执行。在一个系统中处于就绪状态的进程可能有多个，通常将它们排成一个队列，称为就绪队列
3. 阻塞态: 又称为等待(wait)态或睡眠(sleep)态，指进程不具备运行条件，正在等待某个事件的完成

1. 新建态: 进程刚被创建时的状态，尚未进入就绪队列
2. 终止态: 进程完成任务到达正常结束点，或出现无法克服的错误而异常终止，或被操作系统及有终止权的进程所终止时所处的状态。进入终止态的进程以后不再执行，但依然保留在操作系统中等待善后。一旦其他进程完成了对终止态进程的信息抽取之后，操作系统将删除该进程

02 进程相关命令

03 进程号和相关函数

2.3 进程创建

01进程创建

/*
    #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(){
    //创建进程
    pid_t pid = fork();

    //判断创建的进程是父进程还是子进程
    if( pid > 0 ){
        printf("pid : %d \n",pid);
        //父进程
        printf("I am parent process, pid: %d, ppid: %d\n" , getpid(),getppid());
    }else if( pid == 0 ){
        //子进程
        printf("I am child process, pid: %d, ppid: %d\n" , getpid(),getppid());
    }

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

    return 0;
}

2.4 父子进程虚拟地址空间情况

父进程与子进程的执行过程

父子进程虚拟地址空间

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

2.5 父子进程关系及GDB多进程调试

GDB多进程调试

设置调试父进程或者子进程：set follow-fork-mode [parent(默认）| child]
设置调试模式：set detach-on-fork [ on（默认） | off ] （on表示调试当前进程的时候，其他进程继续运行，off表示调试当前进程时，其他进程被GDB挂起）
查看调试的进程：info inferiors
切换当前调试的进程：inferior id
使进程脱离GDB调试：detach inferiors id

注意：GDB8.0往上的版本，调试模式有bug（set datach-on-fork)

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

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

2.6 exec函数族

一系列功能相同或者相似的函数（有点像C++里的函数重载）

01 exec函数族介绍

• exec函数族的作用是根据指定的文件名找到可执行文件，并用它来取代调用进程的内容，换句话说，就是在调用进程内部执行一个可执行文件。
• exec函数族的函数执行成功后不会返回，因为调用进程的实体，包括代码段，数据段和堆栈等都已经被新的内容取代，只留下进程 ID等一些表面上的信息仍保持原样，颇有些神似”三十六计”中的"金蝉脱壳”。看上去还是旧的躯壳，却已经注入了新的灵魂。只有调用失败了，它们才会返回 -1，从原程序的调用点接着往下执行。

## 03 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());
    }else if(pid == 0){
        //子进程
        execl("hello","hello",NULL);

        printf("i am child process, pid : %d\n",getpid());
    }

    for(int i=0;i<5;++i){
        printf("i = %d , pid : %d \n",i,getpid());
    }

    return 0;
}

从下图我们可以发现，子进程执行了execl之后，后面的内容并没有执行

使用execlp不用指定路径也能成功执行，是因为execlp会到环境变量中查找指定的可执行文件，如果找到了就执行，找不到就执行不成功
但是如果execlp里面换成hello程序，hello没有配置环境变量，执行失败。

/*  
    #include <unistd.h>
    int execlp(const char *file, const char *arg, ... );
        - 会到环境变量中查找指定的可执行文件，如果找到了就执行，找不到就执行不成功。
        - 参数：
            - 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(){
    //创建进程
    pid_t pid = fork();

    if(pid >0){
        //父进程
        printf("i am parent process, pid : %d\n",getpid());
    }else if(pid ==0){
        execlp("ps","ps","aux",NULL);
        //execlp("hello","hello",NULL); //failed
        printf("i am child process,pid : %d\n",getpid());
    }

    for(int i=0;i<5;++i){
        printf("i = %d,pid : %d\n",i , getpid());
    }

    return 0;
}

execv

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

execve

int execve(const char *filename, char *const argv[], char *const envp[]);
        char * envp[] = {"/home/nowcoder", "/home/bbb", "/home/aaa"};