Linux系统编程（三）——Linux下的进程

第一篇中总结了系统的环境搭建，第二篇中学习了系统的一些IO函数，接下来就深入到了Linux下的进程线程的实现。

0x01 进程概述

一、进程的信息

二、程序与进程

三、并行与并发

四、进程控制块PCB

0x02 进程状态转换

一、进程的状态

二、进程相关的命令

三、进程号和相关函数

0x03 进程的创建

一、父子进程虚拟地址空间

二、GDB多进程调试

三、代码

0x04 进程的控制

一、进程的退出

二、孤儿进程

三、僵尸进程

四、进程回收

五、函数execl()

0x05 进程间的通信

一、进程间通讯概念

二、匿名管道

三、有名管道

四、使用有名管道实现一个聊天的功能

0x06 内存映射

一、通过内存映射实现进程通信

二、匿名映射

三、通过内存映射实现文件拷贝

四、内存映射注意事项

0x01 进程概述

一、进程的信息

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

二进制格式标识：每个程序文件都包含用于描述可执行文件格式的信息。内核利用此信息来解释文件中的其他信息。（ELF可执行链接格式）
机器语言指令：对程序算法进行编码。
程序入口地址：标识程序开始执行的起始指令位置。
数据：程序文件包含的变量初始值和程序使用的字面量值（比如字符串）
符号表以及重定位表：描述程序中函数和变量的位置及名称。这些表格有多重用途，其中包括调试和运行时的符号解析（动态链接）。
共享库和动态链接信息：程序文共享库件所包含的一些字段，列出了程序运行时需要使用的共享库，以及加载共享库的动态链接器的路径名。
其他信息：程序文件还包含许多其他信息，用以描述如何创建进程。

二、程序与进程

进程是正在运行的程序的实例。是一个具有一定独立功能的程序关于某个数据集合的一次运行获得。它是操作系统动态执行的基本单元，在传统的操作系统中，进程既是基本的分配单元，也是基本的执行单元。

可以用一个程序来创建多个进程，进程是由内核定义的抽象实体，并为该实体分配用以执行程序的各项系统资源。从内核的角度看，进程由用户内存和一系列内核数据结构组成，其中用户内存空间包含了程序代码及代码所使用的变量，而内核数据结构则用于维护进程状态信息。记录在内核数据结构中的信息包括许多与进程相关的标识号（IDs）、虚拟内存表、打开文件的描述符、信号传递及处理的有关信息、进程资源使用及限制、当前工作目录和大量的其他信息。

单道程序，即在计算机内存中只允许一个程序运行。
多道程序设计技术是在计算机内存中存在同时存放几道相互独立的程序，使他们在管理程序控制下，相互穿插运行，两个或两个以上程序在计算机系统中同处于开始到结束之间的状态，这些程序共享计算机系统资源，引入多道程序设计技术的根本目的是为了提高CPU利用率。
对于一个单CPU系统来书，程序同时处于运行状态只是一种宏观上的概念，他们虽然都已经开始运行，但就微观而言，任意时刻，CPU上运行的程序只有一个。
在多道程序设计模型中，多个进程轮流使用CPU。
时间片又称为量子或处理器片，是操作系统分配给每个正在运行的进程微观上的一段CPU时间。事实上，虽然一台计算机通常可能有多个CPU，但同一个CPU永远不可能真正的同时运行多个任务。
时间片由操作系统内核的调度程序分配给每个进程。首先，内核会给每个进程分配相等的初始时间片，然后每个进程轮番的执行相应的时间，当所有进程处于时间片耗尽的状态时，内核会重新为每个进程计算并分配时间片，如此往复。

三、并行与并发

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

四、进程控制块PCB

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

0x02 进程状态转换

一、进程的状态

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

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

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

二、进程相关的命令

查看进程：

ps aux

ps ajx

a:显示终端上的所有进程，包括其他用户的进程。

u:显示进程的详细信息。

x:显示没有控制终端的进程。

j:列出与作业控制相关的信息。

查看当前终端所占的pts：tty
STAT参数的意义

可以在这看到有个STAT参数，其意义如下：

D：不可中断 Uniterruptible

R：正在运行，或在队列中的进程

S（大写）：处于休眠状态

T：停止或被追踪

Z：僵尸进程

W：进入内存交换（从内核2.6开始无效）

X：死掉的进程

<：高优先级

N：低优先级

s：包含子进程

+：位于前台的进程组

对于实时显示进程动态

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

M：根据内存使用量排序

P：根据CPU占有率排序

T：根据进程运行时间长短排序

U：根据用户名来筛选进程

K：输入指定的PID杀死进程

对于杀死进程的处理

kill [-signal] pid

kill -l 列出所有信号

kill -SIGKILL 进程ID

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)

0x03 进程的创建

终端也是个进程，在终端创建一个进程，该进程为子进程，子进程还可以创建新的子进程，形成进程树结构模型。

一、父子进程虚拟地址空间

fork以后，子进程的用户区数据和父进程一样，内核区也会拷贝过来，但是pid是不一样的。

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

fork()创建子进程时继承了父进程的数据段、代码段、栈段、堆，注意从父进程继承来的是虚拟地址空间，同时也复制了页表（没有复制物理块）。因此，此时父子进程拥有相同的虚拟地址，映射的物理内存也是一致的（独立的虚拟地址空间，共享父进程的物理内存）。

二、GDB多进程调试

使用GDB调试的时候，GDB默认只能跟踪一个进程，可以在fork函数调用之前，通过指令设置GDB调试工具跟踪父进程或者是跟踪子进程，默认跟踪父进程。设置调试父进程或者子进程：

set follow-fork-mode [parent（默认）|child]

设置调试模式：

set detach-on-fork [on|off]

默认为on，表示调试当前进程时，其他的进程继续运行，如果为off，调试当前进程的时候，其他进程被GDB挂起。

三、代码

首先看看函数的解析：

#include <sys/types.h>

#include <unistd.h>

pid_t fork(void);

        作用：创建子进程

        返回值：

        返回两次，一次是在父进程中，一次是在子进程中。

                在父进程中返回创建的子进程的ID，在子进程中返回0。（可以通过fork返回值区别父进程以及子进程）

                返回-1，是在父进程中返回的，表示创建子进程失败，并且设置errorno

子进程失败的两个主要原因：

        - 当系统的进程数已经达到了系统规定的上限，这时errno的值被设置为EAGAIN

        - 系统内存不足时，这时errno的值被设置为ENOMEM

父子进程之间的关系：

区别：

        1.fork（）函数的返回值不同

                父进程中>0 返回的子进程的ID

                子进程中=0

        2.pcb中的一些数据

                当前进程的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);
        //如果大于0，返回的是创建子进程的进程号，是父进程
        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;
}

0x04 进程的控制

一、进程的退出

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

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

//status:是进程退出时的一个状态信息，父进程回收子进程资源的时候可以获取到。

这两个函数的区别可以看如下图：

对于使用可以看看如下代码的区别:

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

int main()
{
    printf("hello\n");
    printf("world");

    //exit(0);  会打印world 刷新了缓冲区
    //_exit(0); 不会打印world 没有刷新缓冲区，world留在了缓冲区
    
    return 0;
}

二、孤儿进程

父进程运行结束时，但子进程还结束在运行（未运行未结束），这样的子进程就称为孤儿进程(Orphan Process)
每当出现一个孤儿进程的时候，内核就把孤儿进程的父进程设置为init，而init进程会循环地wait()它的已经退出的子进程。这样，当一个孤儿进程凄凉的结束了它的生命周期，init进程就会处理它的一切善后工作。此时，子进程的父进程ppid为1。
因此孤儿进程并不会有什么危害。

三、僵尸进程

每个进程结束之后，都会释放掉自己地址空间中的用户数据，内核区的PCB没有办法自己释放掉，需要父进程去释放。
进程终止时，父进程尚未回收，子进程残留资源（PCB）存放于内核中，变成僵尸进程。
僵尸进程不能被kill -9杀死。
这样就会导致一个问题，如果父进程不调用wait()或者waitpid()的话，那么保留的那段信息就不会被释放，其进程号就会一直被占用，但是系统所能使用的进程号是有限的，如果大量的产生僵尸进程，将因为没有可用的进程号而导致系统不能产生新的进程，此即为僵尸进程的危害，应当避免。

四、进程回收

为了解决僵尸进程的问题，我们需要实现进程回收。

在每个进程退出的时候，内核释放该进程所有的资源、包括打开的文件、占用的内存等。但是仍然为其保留一定的信息，这些信息主要是指进程控制块PCB信息（包括进程号、退出状态、运行时间等）。
父进程可以通过调用wait或waitpid得到它的退出状态同时彻底清除掉这个进程。
wait和waitpid功能一样，区别在于wait会阻塞（等待），waitpid可以设置不阻塞，waitpid可以指定等待哪个子进程结束。
一次wait或waitpid调用只能清理一个子进程，清理多个子进程应使用循环。

使用fork创建进程的话是进程数指数倍增长。需要使用if语句是防止其继续增长。

首先看看退出信息的相关宏函数：

WIFEXITED(status) 非0，进程正常退出
WEXITSTATUS(status) 如果上宏为真，获取进程退出的状态(exit的参数)

WIFSIGNALED(status) 非0，进程异常终止
WTERMSIG(status) 如果上宏为真，获取使进程终止的信号编号

WIFSTOPPED(status) 非0，进程处于暂停状态
WSTOPSIG(status) 如果上宏为帧，获取使进程暂停的信号的编号
WIFCONTINUED(status) 非0，进程暂停后已经继续运行

那么如果我们要等待子进程的结束，可以先看看wait函数：

#include <sys/types.h>

#include <sys/wait.h>

pid_t wait(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;

    for(int i=0;i<5;i++)
    {
        pid = fork();
        if(pid==0)
        {
            break;  //防止产生孙子进程
        }
    }
    if(pid>0)
    {
        while(1)
        {
            //father
            printf("parent,pid=%d\n",getpid());
            //int ret = wait(NULL);
            int st;
            int ret = wait(&st);
            if(ret==-1)
            {
                break;
            }
            if(WIFEXITED(st))
            {
                //是不是正常退出
                //其实就是exit(0)，取决于exit中的函数
                printf("status:%d\n",WEXITSTATUS(st));

            }
            if(WIFSIGNALED(st))
            {
                //是不是异常终止
                //在后面终端操作 kill -9 就是9
                printf("who do this?:%d\n",WTERMSIG(st));
            }
            printf("child die,pid=%d\n",ret);
            sleep(1);
        }
    }
    else if(pid==0)
    {
        //使用while在另外一个终端杀死子进程
        //while(1)
        //{
            printf("child,pid=%d\n",getpid());
            sleep(1);
            exit(0);
        //}
    }


    return 0;   //exit(0)
}

那么接下来看看waitpid()函数：

#include <sys/types.h>

#include <sys/wait.h>

pid_t waitpid(pid_t pid, int *wstatus, int options);

        功能：回收指定进程号的子进程，可以设置是否阻塞。

        参数：

                pid:

                        - >0：表示某个子进程的pid

                        - =0：回收当前进程组的所有子进程

                        - =-1：表示要回收所有的子进程，相当于wait() 最常用

                        - <-1：某个进程组的组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;

    for(int i=0;i<5;i++)
    {
        pid = fork();
        if(pid==0)
        {
            break;  //防止产生孙子进程
        }
    }
    if(pid>0)
    {
        while(1)
        {
            //father
            sleep(1);
            printf("parent,pid=%d\n",getpid());
            //int ret = wait(NULL);
            int st;
            int ret = waitpid(-1,&st,WNOHANG);
            if(ret==-1)
            {
                break;
            }
            if(ret==0)
            {
                //说明还有子进程存在
                continue;
            }else if(ret > 0)
            {
                continue;
            }
            else if(ret>0)
            {
                if(WIFEXITED(st))
                {
                    //是不是正常退出
                    //其实就是exit(0)，取决于exit中的函数
                    printf("status:%d\n",WEXITSTATUS(st));

                }
                if(WIFSIGNALED(st))
                {
                    //是不是异常终止
                    //在后面终端操作 kill -9 就是9
                    printf("who do this?:%d\n",WTERMSIG(st));
                }

                printf("child die,pid=%d\n",ret);
            }

            sleep(1);
        }
    }
    else if(pid==0)
    {
        //使用while在另外一个终端杀死子进程
        while(1)
        {
            printf("child,pid=%d\n",getpid());
            sleep(1);
        }
        exit(0);
    }
    return 0;   //exit(0)
}

五、函数execl()

#include <unistd.h>

int execl(const char *pathname, const char *arg, ...);

        -参数：

                -path：需要指定的执行的文件的路径或者名称。

                        a.out（相对路径）

                        /home/... （绝对路径）推荐

        - arg：执行可执行文件所需要的参数列表

                第一个参数一般没有什么作用，为了方便，一般写的是执行的程序的名称

                从第二个参数开始往后，就是程序执行所需要的参数列表

                参数最后需要以NULL结束。

        -返回值：

                只有当调用失败，才会有返回值，返回-1，并且设置errno。

                如果调用成功，则没有返回值。

int execlp(const char *file, const char *arg, ...);

        -会到环境变量中查找指定的可执行文件，如果找到了就执行，找不到就执行不成功。

        -参数：

                -file：需要执行的可执行文件的文件名

                a.out ps

int execv(const char* path,char *const argv[]);

        argv是需要的参数的一个字符串数组

                char *argv[] = {"ps","aux",NULL};

                execv("/bin/ps",argv);

还有其他函数诸如：

int execle(const char *pathname, const char *arg, ...);

int execvp(const char *file, char *const argv[]);

int execvpe(const char *file, char *const argv[],char *const envp[]);

-l(list) 参数地址列表，以空指针结尾。

-v(vector) 存有各参数地址的指针数组的地址。

-p(path) 按PATH环境变量指定的目录搜索可执行文件

-e(environment) 存有环境变量字符串地址的指针数组的地址（列出地址路径）

这个函数是可以调用其他的可执行文件进行执行程序，看看代码的实现：

#include <unistd.h>
#include <stdio.h>
#include <sys/types.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);
        //执行Linux下的程序 which ps得到路径
        //execl("/bin/ps","/bin/ps","aux",NULL);
        //从env下找路径
        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;
}

0x05 进程间的通信

一、进程间通讯概念

进程是一个独立的资源分配单元，不同进程（这里所说的进程通常指的是用户进程）之间的资源是独立的，没有关联，不能在一个进程中直接访问另一个进程的资源。但是进程并不是孤立的，不同的进程需要进行信息的交互和状态的传递等，因此需要进程间通信（IPC:Inter Processes Communication）。
进程间通信的目的：

数据传输：一个进程需要将它的数据发送至另一个进程。

通知事件：一个进程需要向另一个或一组进程发送消息，通知他们发生了某种事件（如进程终止时要通知父进程）。

资源共享：多个进程之间共享同样的资源。为了做到这一点，需要内核提供互斥和同步机制。

进程控制：有些进程希望完全控制另一个进程的执行（如debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

二、匿名管道

管道也叫无名管道，它是Unix系统IPC（进程间通信）的最古老形式，所有的Unix系统都支持这种通信机制。
统计一个目录中文件的数目命令：ls | wc -l，为了执行该命令，shell创建了两个进程来执行ls和wc。

管道的特点

管道其实是一个在内核内存中维护的缓冲器，这个缓冲器的存储能力是有限的，不同的操作系统大小不一定相同。
管道拥有文件的特质：读操作、写操作，匿名管道没有文件实体，有名管道有文件实体，但不存储数据。可以按照操作文件的方式对管道进行操作。
一个管道是一个字节流，使用管道时不存在消息或者消息边界的概念，从管道读取数据的进程可以读取任意大小的数据块，而不管写入进程写入管道的数据块的大小是多少。
通过管道传递的数据是顺序的，从管道中读取出来的字节的顺序和他们被写入管道的顺序是完全一样的。
在管道中的数据的传递方向是单向的，一端用于写入，一端用于读取，管道是半双工的。
从管道读数据是一次性操作，数据一旦被读走，它就从管道中被抛弃，释放空间以便写更多的数据，在管道中无法使用lseek()来随机的访问数据。
匿名管道只能在具有公共祖先的进程（父进程与子进程，或两个兄弟进程，具有亲缘关系）之间使用。

为什么可以使用管道来进行进程间的通讯

可以理解为磁盘上的一处内存，使用fork进行操作后，父子进程都可以进行读写，都是位于同一个区域，因为fork后复制的是文件描述符表，都是一样的。

管道的数据结构

环形队列。使用逻辑的手段进行实现：

管道是一种队列类型的数据结构，它的数据从一端输入，另一端输出。管道最常见的应用是连接两个进程的输入输出，即把一个进程的输出编程另一个进程的输入。

可以通过命令： ulimit -a来查看管道缓冲区的大小。

可以使用命令修改大小：ulimit -p

当然，可以通过程序来获取管道的大小：

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

int main()
{
    int pipefd[2];

    int ret = pipe(pipefd);
    //获取管道大小
    long size = 0;
    size = fpathconf(pipefd[0],_PC_PIPE_BUF);

    printf("pipe size:%ld\n",size);

    return 0;
}

管道的读写特点及需要注意的特殊情况（假设阻塞IO的操作）

所有的指向管道写端的文件描述符都关闭了，（管道写端的引用计数为0），有进程从管道的读端读数据，管道中剩余的数据被读取以后，再次去read会返回0，第一次是读到的字节数。就像读到文件末尾一样。
如果有指向管道写端的文件描述符没有关闭（管道的写端引用计数大于0），而持有管道写端的进程也没有往管道中写数据，这个时候有进程从管道中读取数据，那么管道中剩余的数据被读取后，再次read会阻塞，直到管道中有数据可以读了，才读数据并返回。
如果所有指向管道读端的文件描述符都关闭了（管道读端引用计数为0），这个时候有向管道中写数据，那么该进程会收到一个信号SIGPIPE，通常会导致进程异常终止。
如果有指向管道读端的文件描述符没有关闭（管道的读端引用计数大于0），而持有管道读端的进程也没有从管道中读数据，这时有进程向管道中写数据，那么在管道被写满的时候，再次去调用write，会阻塞，直到管道中有空位置，才写入数据并返回。

总结：

        读管道：管道中有数据，read返回实际读到的字节数。

                管道无数据：

                写端被全部关闭，read返回0，相当于读到文件的末尾。

                写端没有完全关闭，read阻塞等待。

        写管道：管道读端全部被关闭，进程异常终止（进程收到SIGPIPE信号）

                管道读端没有全部关闭：

                管道已满，write阻塞。

                管道没有满，write将数据写入，并返回实际写入的字节数。

可以看看代码：

#include <unistd.h>

int pipe(int pipefd[2]);

        功能：创建一个匿名管道，用于进程间通信。

        参数：int pipefd[2] 这个数组是一个传出参数

                        pipefd[0] 对应的是管道的读端

                        pipefd[1] 对应的是管道的写端

        返回值：返回文件描述符（具有文件特质，读取以及写入）

                        0 成功

                        -1 失败

注意：

匿名管道只能用于具有关系的进程之间的通信（父子进程、兄弟进程）

管道默认是阻塞的，如果管道中没有数据，read阻塞，如果管道满了，write阻塞

eg:

1.子进程发送数据给父进程，父进程读取到数据输出

2.子进程不断发送数据

对于第一种情况的代码比较简单，子进程发送数据给父进程，父进程读取到数据并且进行输出：

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

int main()
{
    //在fork之前创建管道
    int pipefd[2];
    int ret = pipe(pipefd);

    if(ret==-1)
    {
        perror("pipe");
        exit(0);
    }

    //创建子进程
    pid_t pid = fork();
    if(pid>0)
    {
        //父进程
        //从管道的读取端读取数据
        char buf[1024] = {0};
        //阻塞
        int length = read(pipefd[0],buf,sizeof(buf));
        printf("parent recv:%s,pid:%d\n",buf,getpid());
    }
    else if(pid==0)
    {
        sleep(1);
        //子进程
        //写入
        char *str = "hellohello,i write something to you!";
        write(pipefd[1],str,strlen(str));
    }

    return 0;
}

那么对于第二种情况，子进程不断自己发送数据，这个时候就需要用到总结里面的结论，这个时候需要避免死锁，所以父子进程的读写顺序一定需要相反：

int main()
{
    //在fork之前创建管道
    int pipefd[2];
    int ret = pipe(pipefd);

    if(ret==-1)
    {
        perror("pipe");
        exit(0);
    }

    //创建子进程
    pid_t pid = fork();
    if(pid>0)
    {
        //父进程
        //从管道的读取端读取数据
        printf("I am parent process,pid:%d\n",getpid());
        char buf[1024] = {0};
        while(1)
        {
            //阻塞
            int length = read(pipefd[0],buf,sizeof(buf));
            printf("parent recv:%s,pid:%d\n",buf,getpid());
            //清空
            bzero(buf,1024);
            //写入
            char *str = "hellohello,i write something to you!parent!!";
            write(pipefd[1],str,strlen(str));
            //没有延时会有bug 自己发自己收，一般我们不这么做，我们只弄单向流向
            //可以使用延迟，也可以使用close(pipefd[0])这样的形式去进行关闭，并且把对应程序删除
            sleep(2);
        }
    }
    else if(pid==0)
    {
        printf("I am child process,pid:%d\n",getpid());
        char buf[1024] = {0};
        while(1)
        {
            //向管道中写入数据
            char *str = "hellohello,i write something to you!child!!";
            write(pipefd[1],str,strlen(str));
            sleep(2);
            //避免互相阻塞，顺序一定要相反，否则出现死锁
            int length = read(pipefd[0],buf,sizeof(buf));
            printf("child recv:%s,pid:%d\n",buf,getpid());
            //清空
            bzero(buf,1024);
        }
        
    }

    return 0;
}

三、有名管道

匿名管道，由于没有名字，只能用于亲缘关系的进程间通信，为了克服这个缺点，提出了有名管道（FIFO），也叫命名管道、FIFO文件。
有名管道（FIFO）不同于匿名管道之处在于它提供了一个路径名与之关联，以FIFO的文件形式存在于文件系统中，并且其打开方式与打开一个普通文件是一样的，这样即使与FIFO的创建进程不存在亲缘关系的进程，只要可以访问该路径，就能够彼此通过FIFO相互通信，因此，通过FIFO不相关的进程也能交换数据。
一旦打开了FIFO，就能在它上面使用与操作匿名管道和其他文件的系统调用一样的IO系统调用（如read()\write()\close()）。与管道一样，FIFO也有一个写入端和读取端，并且从管道中读取数据的顺序和写入的顺序是一样的。FIFO的名称也由此而来：先入先出。
有名管道（FIFO）和匿名管道（PIPE）有一些特点是相同的，不一样的地方在于：
1. FIFO在文件系统作为一个特殊文件存在，但FIFO中的内容却存放在内存中。
2. 当使用FIFO的进程退出后，FIFO文件将继续保存在文件系统中以便以后使用。
3. FIFO有名字，不相关的进程可以通过打开有名管道进行通信。

有名管道的使用：

mkfifo 名字

可以看看代码：

创建fifo文件：

        1.通过命令：mkfifo名字

        2.通过函数：

#include <sys/types.h>

#include <sys/stat.h>

int mkfifo(const char *pathname, mode_t mode);

参数：

        -pathname:管道名称的路径

        -mode：文件的权限和open的mode是一样的,八进制

返回值：

        0 成功

        -1 失败，设置errno

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

int main()
{
    // 判断文件是否存在
    int ret = access("fifo1",F_OK);
    if(ret = -1)
    {
        ret = mkfifo("fifo1",0664);

        if(ret == -1)
        {
            perror("mkfifo");
            exit(0);
        }
    }                                            

    return 0;
}

一旦使用了mkfifo创建了一个FIFO，就可以使用open打开它，常见的文件IO函数可用于fifo。如close、read、write、unlink等。
FIFO严格遵循先进先出，对管道及FIFO的读总是从开始处返回数据，对他们的写则把数据添加到末尾。他们不支持诸如lseek()等文件定位操作。

注意事项：

一个为只读而打开一个管道的进程会阻塞，直到另一个进程为只写打开管道。
一个为只写而打开一个管道的进程会阻塞，直到另一个进程为只读打开管道。

总结：

读管道：

管道中有数据：read返回实际读到的字节数。

管道中无数据：管道写端被全部关闭，read返回0（相当于读到文件末尾）。

管道写端没有全部被关闭，read阻塞等待。

写管道：

管道读端被全部关闭，进程异常终止（收到SIGPIPE）

管道读端没有全部关闭：

管道已经满了，write会阻塞。

管道没有满，write将数据写入，并返回实际写入的字节数。

四、使用有名管道实现一个聊天的功能

思路：

通过有名管道完成一个聊天的功能，需要创建两个有名管道：
进程A：
    - 以只写的方式打开管道1
    - 以只读的方式打开管道2
    - 循环写读数据while(1)
    {
        获取键盘录入的数据（fgets()））
        写管道1

        读管道2

    }
进程B：
    - 以只读的方式打开管道1
    - 以只写的方式打开管道2
    - 循环读写数据while(1)
    {
        读管道1

        获取键盘录入的数据（fgets()））
        写管道2
    }

对于这种半双工的通讯，我们需要声明两个管道，一个管道是A向B的传输，另一个管道是B向A的传输，那么对于进程A的代码可以这么写：

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>

int main()
{
    //判断管道文件是否存在
    int ret = access("fifo1",F_OK);
    if(ret==-1)
    {
        //文件不存在
        printf("no fifo!!make it!!\n");
        ret = mkfifo("fifo1",0664);
        if(ret==-1)
        {
            perror("mkfifo");
            exit(0);
        }
    }
    ret = access("fifo2",F_OK);
    if(ret==-1)
    {
        //文件不存在
        printf("no fifo!!make it!!\n");
        ret = mkfifo("fifo2",0664);
        if(ret==-1)
        {
            perror("mkfifo");
            exit(0);
        }
    }
    
    //以只写的方式打开fifo1
    int fdw = open("fifo1",O_WRONLY);
    if(fdw == -1)
    {
        perror("open");
        exit(0);
    }

    printf("open fifo1 success! waiting write in ... \n");

    //以只读的方式打开fifo2
    int fdr = open("fifo2",O_RDONLY);
    if(fdr == -1)
    {
        perror("open");
        exit(0);
    }

    printf("open fifo2 success! waiting read in ... \n");

    char buf[128];

    //循环写读数据
    while(1)
    {
        memset(buf,0,128);
        //获取标准输入的数据
        fgets(buf,128,stdin);
        //写数据
        ret = write(fdw,buf,strlen(buf));
        if(ret == -1)
        {
            perror("write");
            exit(0);
        }
        //读管道数据
        memset(buf,0,128);
        ret = read(fdr,buf,128);
        if(ret<=0)
        {
            perror("read");
            break;
        }
        printf("buf:%s\n",buf);
    }
    //关闭文件描述符
    close(fdr);
    close(fdw);

    return 0;
}

那么对于进程B的代码需要这么写：

#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>

int main()
{
    //判断管道文件是否存在
    int ret = access("fifo1",F_OK);
    if(ret==-1)
    {
        //文件不存在
        printf("no fifo!!make it!!\n");
        ret = mkfifo("fifo1",0664);
        if(ret==-1)
        {
            perror("mkfifo");
            exit(0);
        }
    }
    ret = access("fifo2",F_OK);
    if(ret==-1)
    {
        //文件不存在
        printf("no fifo!!make it!!\n");
        ret = mkfifo("fifo2",0664);
        if(ret==-1)
        {
            perror("mkfifo");
            exit(0);
        }
    }
    
    //以只读的方式打开fifo1
    int fdr = open("fifo1",O_RDONLY);
    if(fdr == -1)
    {
        perror("open");
        exit(0);
    }

    printf("open fifo1 success! waiting read in ... \n");

    //以只写的方式打开fifo2
    int fdw = open("fifo2",O_WRONLY);
    if(fdw == -1)
    {
        perror("open");
        exit(0);
    }

    printf("open fifo2 success! waiting write in ... \n");

    char buf[128];

    //循环读写数据
    while(1)
    {
        //读管道数据
        memset(buf,0,128);
        ret = read(fdr,buf,128);
        if(ret<=0)
        {
            perror("read");
            break;
        }
        printf("buf:%s\n",buf);

        memset(buf,0,128);
        //获取标准输入的数据
        fgets(buf,128,stdin);
        //写数据
        ret = write(fdw,buf,strlen(buf));
        if(ret == -1)
        {
            perror("write");
            exit(0);
        }
    }
    //关闭文件描述符
    close(fdr);
    close(fdw);

    return 0;
}

0x06 内存映射

内存映射是将磁盘文件的数据映射到内存，用户通过修改内存就能修改磁盘文件。

一、通过内存映射实现进程通信

那么这样我们也可以通过使用内存映射来实现进程间的通信，思路在于：

1.有关系的进程（父子进程）

        -还没有子进程的时候

                -通过唯一的父进程，先创建内存映射区

        -有了内存映射区后，创建子进程

        -父子进程共享创建的内存映射区

2.没有关系的进程间通信

        -准备一个大小不是0的磁盘文件

        -进程1 通过磁盘文件创建内存映射区

                -得到一个操作这块内存的指针

        -进程2 通过磁盘文件创建内存映射区

                -得到一个操作这块内存的指针

        -使用内存映射区通信

注意：内存映射区通信，是非阻塞。

那么首先我们可以看看实现内存映射的函数mmap：

#include <sys/mman.h>
void *mmap(void *addr, size_t length, int prot, int flags,int fd, off_t offset);
    -功能：将一个文件或者设备的数据映射到内存中
    -参数：
        -void *addr：NULL，由内核指定，否则为指定内存的首地址（我们无法知道）
        -length：要映射的数据的长度，这个值不能为0。建议使用文件的长度。可以使用stat以及lseek函数。
                给定分页的整数倍大小。
        -int prot：对申请的内存映射区的操作权限。 
            PROT_EXEC  可执行权限
            PROT_READ  读的权限
            PROT_WRITE 写权限
            PROT_NONE  没有权限
            要操作映射内存，必须要有读的权限。所以一般是一读权限，或者其他权限跟读权限按位或。
        - flag：
            MAP_SHARED：映射区的数据会自动和磁盘文件进行同步，进程间通讯，必须要设置这个选项。
            MAP_PRIVATE：不同步，内存映射区的数据改变了，对原来的文件不会修改，会重新创建一个新的文件。（copy on write）
         - fd：需要映射的那个文件的文件描述符
            通过open得到的，open是一个磁盘文件。
            注意：文件的大小不能为0，open指定的权限不能和prot参数有冲突。
                prot：PROT_READ                 open：只读、读写
                prot：PROTT_READ | PROT_WRITE   open：读写
                必须要有read，权限要小于open的权限。
        - off_t offset：映射的偏移量，一般不用，必须指定的是4K的整数倍，0表示不偏移。
    -返回值：返回创建的内存的首地址，如果失败，则返回MAP_FAILED,(void*) -1，并且设置errno。
        
int munmap(void *addr, size_t length);
        -功能：释放内存映射
        -参数:
            -addr:要释放的内存的首地址。
            -length：要释放的内存的大小，要和mmap函数中的length参数的值一样。

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

int main()
{
    //打开文件
    int fd = open("test.txt",O_RDWR);
    //获取文件大小
    int size = lseek(fd,0,SEEK_END);
    //创建内存映射区
    void *ptr = mmap(NULL,size,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    if(ptr == MAP_FAILED)
    {
        perror("mmap");
        exit(0);
    }
    //创建子进程
    pid_t pid = fork();
    if(pid>0)
    {
        wait(NULL);
        char buf[64];
        strcpy(buf,(char *)ptr);
        printf("read date:%s\n",buf);
        
    }
    else if(pid==0)
    {
        strcpy((char *)ptr,"hello my parent!!");
    }
    //关闭内存映射区
    munmap(ptr,size);

    return 0;
}

二、匿名映射

不需要文件实体进行一个内存映射，也可以用于做父子进程间的通信（只可以父子进程间）。

#include <stdio.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/wait.h>

int main()
{
    //1. 创建匿名映射区
    int length = 4096;
    void *ptr = mmap(NULL,length,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANONYMOUS,-1,0);
    if(ptr==MAP_FAILED)
    {
        perror("mmap");
        exit(0);
    }

    //父子进程间通信
    pid_t pid=fork();

    if(pid>0)
    {
        //父进程
        strcpy((char *)ptr,"hello world");
        wait(NULL);
    }
    else if(pid==0)
    {
        //子进程
        sleep(1);
        printf("%s\n",(char *)ptr);
    }

    //释放
    int ret = munmap(ptr,length);
    if(ret==-1)
    {
        perror("munmap");
        exit(0);
    }

    return 0;
}

三、通过内存映射实现文件拷贝

1.对原始的文件进行内存映射。

2.创建一个新文件并拓展

3.把新文件的数据映射到内存中

4.通过内存拷贝将第一个文件的内存数据拷贝到新的文件内存中

5.释放资源

#include <stdio.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>

int main()
{
    //1.对原始的文件进行内存映射。
    int fd = open("chat.txt",O_RDWR);
    if(fd==-1)
    {
        perror("open");
        exit(0);
    }
    //获取文件长度便于下面扩展
    int len = lseek(fd,0,SEEK_END);

    //2.创建一个新文件并拓展
    int fd1 = open("cpy.txt",O_RDWR|O_CREAT,0664);
    if(fd1==-1)
    {
        perror("open");
        exit(0);
    }
    //对新创建的文件进行扩展
    truncate("cpy.txt",len);
    write(fd1," ",1);

    //3.把新文件的数据映射到内存中
    void *ptr = mmap(NULL,len,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
    void *ptr1 = mmap(NULL,len,PROT_READ|PROT_WRITE,MAP_SHARED,fd1,0);

    if(ptr==MAP_FAILED)
    {
        perror("mmap");
        exit(0);
    }
    if(ptr1==MAP_FAILED)
    {
        perror("mmap");
        exit(0);
    }

    //内存拷贝
    memcpy(ptr1,ptr,len);

    //释放资源
    munmap(ptr1,len);
    munmap(ptr,len);

    close(fd1);
    close(fd);

    return 0;
}

四、内存映射注意事项

如果对mmap的返回值(ptr)做++操作(ptr++)，是否可以munmap成功关闭内存映射区？

可以对其进行++操作，但是不建议，因为munmap会不能正确释放，需要保存地址。
如果open时O_RDONLY，mmap时port参数指定PROT_READ|PROT_WRITE会怎么样？

错误，返回MAP_FAILED；open函数中的权限建议和port参数的权限保持一致。
如果文件偏移量为1000怎么办？

偏移量里必须是4k的整数倍，返回MAP_FAILED
mmap什么情况下会调用失败？
- 第二个参数：length = 0
- 第三个参数：port（只指定了写权限或权限超过open的权限）
- 偏移量不是4k整数倍
可以open的时候O_CREAT一个新文件来创建映射区吗？

可以的，但是创建的文件大小如果为0的话，肯定不行。可以对新的文件进行扩展，使用lseek，truncate。
mmap后关闭文件描述符，对mmap映射有没有影响？

比如：

int fd = open("XXX");

mmap(...fd,0);

close(fd);

这个时候映射区还存在，创建映射区的fd被关闭了，没有任何影响。
ptr越界操作会怎么样？

越界操作的是非法内存，会发生段错误。