一. 过程间通信

1.1 什么是过程间通信

咱们运行起来的过程，相互之间资源是独立的，不能在一个过程中间接拜访另一个过程的资源。
然而很多时候不同的过程须要进行信息的交互和状态的传递等，譬如数据传输，一个过程须要将它的数据发送给另一个过程，或者多个过程间资源共享，或者一个过程须要管制另一个过程的执行，再或者，一个过程要给另一个过程发送音讯等，就须要过程间通信(IPC：Inter Processes Communication)。

1.2 过程间通信的形式

过程间通信的形式有很多，文件、管道、信号、共享内存映射、音讯队列、套接字、命名管道等。这里说管道 pipe，命名管道 fifo，共享内存映射。

二. 管道 PIPE

2.1 管道概述

管道是一种最根本的 IPC 机制，也称匿名管道、无名管道，利用于有血缘关系的过程之间，实现数据传递。
所有的 UNIX 零碎都反对这种通信机制。

管道的实质是一块内核缓冲区，由两个文件描述符援用，一个示意读端，一个示意写端。
管道是半双工，规定数据从管道的写端流入管道，从读端流出，当两个过程都终结的时候，管道也主动隐没，管道的读端和写端默认都是阻塞的。

管道的数据一旦被读走，便不在管道中存在，不可重复读取，数据只能在一个方向上流动，若要实现双向流动，必须应用两个管道。

只能在有血缘关系的过程间应用管道

创立管道非常简单，调用 pipe 函数即可

2.2 pipe 函数

#include <unistd.h>
​
int pipe(int pipefd[2]);
性能：创立无名管道。​
参数：pipefd : 为 int 型数组的首地址，其寄存了管道的文件描述符 pipefd[0]、pipefd[1]。当一个管道建设时，它会创立两个文件描述符 fd[0] 和 fd[1]。其中 fd[0] 固定用于读管道，而 fd[1] 固定用于写管道。个别文件 I/ O 的函数都能够用来操作管道(lseek() 除外)。​
返回值：胜利：0
    失败：-1

代码示例

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

/* pipe 函数演示 */
int main(){int fd[2];
    int ret = pipe(fd); // 创立管道

    if(ret<0){ 
        // 创立管道失败
        perror("pipe");
        return -1;
    }

    pid_t pid = fork();
    if(pid < 0){
        // 创立过程失败
        perror("fork");
        return -1;
    }else if(pid > 0){
        // 父过程 
        close(fd[0]);
        // 父过程写入 fd[1]
        write(fd[1],"hello",strlen("hello"));
        wait(NULL);

    }else {
        // 子过程读取
        char buf[128];
        memset(buf,0,sizeof(buf));
        int n = read(fd[0],buf,sizeof(buf));
        printf("%s\n",buf);
    }
}

2.3 管道的读写行为注意事项

这里假设都是阻塞 I / O 操作，咱们应用管道须要留神以下 4 种非凡状况：
1) 如果所有指向管道写端的文件描述符都敞开了，而依然有过程从管道的读端读数据，那么管道中残余的数据都被读取后，再次 read 会返回 0，就像读到文件开端一样。

2) 如果有指向管道写端的文件描述符没敞开，而持有管道写端的过程也没有向管道中写数据，这时有过程从管道读端读数据，那么管道中残余的数据都被读取后，再次 read 会阻塞，直到管道中有数据可读了才读取数据并返回。

3) 如果所有指向管道读端的文件描述符都敞开了，这时有过程向管道的写端 write，那么该过程会收到信号 SIGPIPE，通常会导致过程异样终止。当然也能够对 SIGPIPE 信号施行捕获，不终止过程。具体方法信号章节具体介绍。

4) 如果有指向管道读端的文件描述符没敞开，而持有管道读端的过程也没有从管道中读数据，这时有过程向管道写端写数据，那么在管道被写满时再次 write 会阻塞，直到管道中有空地位了才写入数据并返回。

默认管道的读写两端为阻塞的 IO 操作，但也能够设置为非阻塞，办法也很简略，就是应用 fcntl 函数，设置 O_NONBLOCK 标记标记。

// 获取原来的 flags
int flags = fcntl(fd[0], F_GETFL);
// 设置新的 flags
flag |= O_NONBLOCK;
// flags = flags | O_NONBLOCK;
fcntl(fd[0], F_SETFL, flags);

2.4 查看缓冲区

管道实质是一个内核缓冲区，那么如何查看缓冲区大小呢？
1）ulimit -a

(base) zhaow@zhaow-610:~$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 62944
max locked memory       (kbytes, -l) 65536
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8 // 管道缓冲区大小
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 62944
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

2）fpathconf 函数

#include <unistd.h>
​
long fpathconf(int fd, int name);
性能：该函数能够通过 name 参数查看不同的属性值
参数：fd：文件描述符
    name：_PC_PIPE_BUF，查看管道缓冲区大小
        _PC_NAME_MAX，文件名字字节数的下限
返回值：胜利：依据 name 返回的值的意义也不同。失败：-1

示例

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

int main(){int fd[2];
    int ret = pipe(fd);
    if(ret <0){perror("pipe");
        return -1;
    }
    printf("pipe read size==[%ld]\n", fpathconf(fd[0], _PC_PIPE_BUF));
    printf("pipe write size==[%ld]\n", fpathconf(fd[1], _PC_PIPE_BUF));

    return 0;

}

三. 命名管道（FIFO）

3.1 概述

管道 (pipe) 只能用于“有血缘关系”的过程间通信，为了补救这个缺点，提出了命名管道（FIFO），也叫有名管道、FIFO 文件。

命名管道（FIFO）提供了一个路径名与之关联，以 FIFO 的文件模式存在于文件系统中，这样即便与 FIFO 的创立过程不存在亲缘关系的过程，只有能够拜访该门路，就可能彼此通过 FIFO 互相通信，因而，通过 FIFO 不相干的过程也能替换数据。

FIFO 是 Linux 根底文件类型中的一种（文件类型为 p，可通过 ls - l 查看文件类型）。
FIFO 文件在磁盘上没有数据块，仅仅用来标识内核中一条通道，过程关上这个文件进行 read/write，实际上是在读写内核缓冲区。

3.2 创立 fifo

1）命令 mkfifo

(base) zhaow@zhaow-610:demo$ mkfifo myfifo
(base) zhaow@zhaow-610:demo$ ls -l
总用量 0
prw-rw-r-- 1 zhaow zhaow 0 8 月  21 02:42 myfifo  // 文件类型 p

2）函数 mkfifo

#include <sys/types.h>
#include <sys/stat.h>
​
int mkfifo(const char *pathname, mode_t mode);
性能：命名管道的创立。参数：pathname : 一般的路径名，也就是创立后 FIFO 的名字。mode : 文件的权限，与关上一般文件的 open() 函数中的 mode 参数雷同。(0666)
返回值：胜利：0   状态码
    失败：如果文件曾经存在，则会出错且返回 -1。

3.3 代码示例

过程 A 写入

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

int main()
{
    // 创立 fifo 文件
    // 1. 查看是否存在，不存在则创立
    int ret = access("./myfifo", F_OK);
    if(ret!=0)
    {ret = mkfifo("./myfifo", 0777);
        if(ret<0)
        {perror("mkfifo error");
            return -1;
        }
    }

    // 关上文件
    int fd = open("./myfifo", O_RDWR);
    if(fd<0)
    {perror("open error");
        return -1;
    }

    // 写 fifo 文件
    int i = 0;
    char buf[64];
    while(1)
    {memset(buf, 0x00, sizeof(buf));
        sprintf(buf, "%d:%s", i, "hello world");
        write(fd, buf, strlen(buf));
        sleep(1);

        i++;
    }

    
    close(fd);


    return 0;
}

过程 B 读取

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


int main(){
    // 1. 查看要创立的 fifo 文件是否存在，若不存在则创立
    int ret = access("./myfifo",F_OK);
    if(ret != 0){ret = mkfifo("./myfifo",0777);
        if(ret < 0){perror("mkfifo");
            return -1;
        }
    }

    // 关上 fifo

    int fd = open("./myfifo",O_RDWR);
    if(fd<0){perror("open");
        return -1;
    }

    // 读取
    int n;
    char buf[128];
    while (1)
    {memset(buf,0x00,sizeof(buf));
        n = read(fd,buf,sizeof(buf));
        printf("buf=[%s]\n",buf);
    }
    
    close(fd);

    return 0;
}

四. 共享存储映射

4.1 概述

存储映射 I /O (Memory-mapped I/O) 就是使一个磁盘文件与存储空间中的一个缓冲区相映射。
从缓冲区中取数据，就如同读文件中的相应字节；同样，将数据写入缓冲区，则会将数据写入文件。

4.2 存储映射函数

1)mmap

#include <sys/mman.h>
​
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
1 用处: 一个文件或者其它对象映射进内存)
2 参数阐明：addr :  指定映射的起始地址, 通常设为 NULL, 由零碎指定
    length：映射到内存的文件长度
    prot：映射区的保护方式, 罕用的三种
        1) 读：PROT_READ
        2) 写：PROT_WRITE
        3) 读写：PROT_READ | PROT_WRITE
    flags：映射区的个性, 能够是
        1) MAP_SHARED : 写入映射区的数据会复制回文件, 且容许其余映射该文件的过程共享。2) MAP_PRIVATE : 对映射区的写入操作会产生一个映射区的复制(copy - on - write), 对此区域所做的批改不会写回原文件。fd：由 open 返回的文件描述符, 代表要映射的文件。offset：以文件开始处的偏移量, 必须是 4k 的整数倍, 通常为 0, 示意从文件头开始映射
返回值：胜利：返回创立的映射区首地址
    失败：MAP_FAILED 宏
​

2)munmap

#include <sys/mman.h>
​
int munmap(void *addr, size_t length);
性能：开释内存映射区
参数：addr：应用 mmap 函数创立的映射区的首地址
    length：映射区的大小
返回值：胜利：0
    失败：-1

代码示例 父子过程间通信

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

int main(){int fd = open("./ts.log",O_RDWR); // 当映射文件大小为 0 时，不能创立映射区, 所以，用于映射的文件必须要有理论大小;
    if(fd < 0){perror("open");
        return -1;
    }

    int len = lseek(fd,0,SEEK_END);

    void * addr = mmap(NULL,len,PROT_READ |PROT_WRITE,MAP_SHARED,fd,0);

    if(addr == MAP_FAILED){ // mmap 创立映射区出错概率十分高，肯定要查看返回值，确保映射区建设胜利再进行后续操作
        perror("mmap");
        return -1;
    }

    close(fd); // 映射区的开释与文件敞开无关，只有映射建设胜利，文件能够立刻敞开。pid_t pid = fork();
    if(pid < 0){perror("fork");
        return -1;
    }else if(pid > 0){memcpy(addr,"hello",strlen("hello"));
        wait(NULL);
    }else{char buf[64];
        memset(buf,0x00,sizeof(buf));
        memcpy(buf,addr,5);
        printf("%s\n",buf);
    }

    return 0;
}

4.3 匿名映射实现父子过程通信

应用映射区来实现文件读写操作非常不便，父子过程间通信也较容易，但比拟麻烦的是，每次创立映射区肯定要依赖一个文件能力实现，为了建设映射区要 open 一个 temp 文件，创立好了再 unlink、close 掉，很麻烦。
Linux 零碎提供了创立匿名映射区的办法，无需依赖一个文件即可创立映射区。同样须要借助标记位参数 flags 来指定。

int *p = mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
参数阐明：4" 随便，该地位示意映射区大小，可依理论须要填写。MAP_ANONYMOUS 和 MAP_ANON 这两个宏是 Linux 操作系统特有的宏。

代码示例

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

int main(){void * addr = mmap(NULL,4096,PROT_READ|PROT_WRITE,MAP_SHARED | MAP_ANONYMOUS,-1,0);
    if(addr==MAP_FAILED)
    {perror("mmap");
        return -1;
    }

    pid_t pid  = fork();
    if(pid < 0){perror("fork");
        return -1;
    }else if(pid > 0){memcpy(addr,"hello",strlen("hello"));
        wait(NULL);
    }else{char buf[64];
        memset(buf,0x00,strlen(buf));
        memcpy(buf,addr,5);
        printf("%s\n",buf);
    }

    return 0;
}