Linux进程通信01-无名管道、有名管道、共享存储映射

进程间通讯概念

进程是一个独立的资源分配单元，不同进程之间无法直接访问对方资源。但又由于进程间需要交互，故需要进程间通信。

进程间通信的目的：
1. 数据传输：一个进程需要将它的数据发送给另一个进程。
2. 通知事件：一个进程需要向另一个或一组进程发送消息，通知其发生了某种事件。
3. 资源共享：多个进程之间共享同样的资源（需要内核提供互斥和同步机制）。
4. 进程控制：有些进程希望完全控制另一个进程的执行（如 Debug 进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变。

Linux 操作系统支持的主要进程间通信的通信机制：

管道（无名管道）

所有UNIX 系统 进行IPC（进程间通信）均支持的古老形式。

管道特点：
1. 半双工，数据在同一时刻只能在一个方向上流动。
2. 数据只能从管道的一端写入，从另一端读出。
3. 写入管道中的数据遵循先进先出的规则。
4. 管道所传送数据无格式(故两端需商议好）
5. 不是文件不属于文件系统，仅存于内存
6. 管道在内存中对应一个缓冲区，不同系统大小不同。
7. 读数据一次性。
8. 管道无名，只能在具有公共祖先的进程中使用。

管道是一种特殊类型的文件，在应用层体现为两个打开的文件描述符。

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

例子：

int main()
{
    int fd_pipe[2] = { 0 };
    pid_t pid;
​
    if (pipe(fd_pipe) < 0)
    {// 创建管道
        perror("pipe");
    }
​
    pid = fork(); // 创建进程
    if (pid == 0)
    { // 子进程
        char buf[] = "I am mike";
        // 往管道写端写数据
        write(fd_pipe[1], buf, strlen(buf));
​
        _exit(0);
    }
    else if (pid > 0)
    {// 父进程
        wait(NULL); // 等待子进程结束，回收其资源
        char str[50] = { 0 };
​
        // 从管道里读数据
        read(fd_pipe[0], str, sizeof(str));
​
        printf("str=[%s]\n", str); // 打印数据
    }
​
    return 0;
}
​

管道读写情况总结

读管道：
Ø 管道中有数据，read返回实际读到的字节数。
Ø 管道中无数据：
u 管道写端被全部关闭，read返回0 (相当于读到文件结尾)
u 写端没有全部被关闭，read阻塞等待(不久的将来可能有数据递达，此时会让出cpu)

写管道：
Ø 管道读端全部被关闭， 进程异常终止(也可使用捕捉SIGPIPE信号，使进程终止)
Ø 管道读端没有全部关闭：
u 管道已满，write阻塞。
u 管道未满，write将数据写入，并返回实际写入的字节数。

设置为非阻塞

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

结论： 如果写端没有关闭，读端设置为非阻塞， 如果没有数据，直接返回-1。

查看管道缓冲区大小

1. ulimit -a 命令
   

2. 查看管道缓冲区函数

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

   示例：

   int main()
   {
       int fd[2];
       int ret = pipe(fd);
       if (ret == -1)
       {
           perror("pipe error");
           exit(1);
       }
   ​
       long num = fpathconf(fd[0], _PC_PIPE_BUF);
       printf("num = %ld\n", num);
   ​
       return 0;
   }
   

有名管道（FIFO文件）

有名管道克服了无名管道的缺点（只能用于亲缘关系的进程间通信）。

有名管道和无名管道区别：
1. FIFO以特殊文件在文件系统中存在，FIFO 中内容却存放在内存中。
2. 使用 FIFO 的进程退出后，FIFO 文件仍存在于文件系统，独立于所使用的进程。
3. 有对应名字

有名管道的创建

1. 命令 mkfifo filename
   
2. 函数创建有名管道

   #include <sys/types.h>
   #include <sys/stat.h>
   ​
   int mkfifo(const char *pathname, mode_t mode);
   功能：
       命名管道的创建。
   参数：
       pathname : 普通的路径名，也就是创建后 FIFO 的名字。
       mode : 文件的权限，与打开普通文件的 open() 函数中的 mode 参数相同。(0666)
   返回值：
       成功：0   状态码
       失败：如果文件已经存在，则会出错且返回 -1。
   

有名管道读写

1. 可使用open打开，常见文件均可用于fifo。如：close、read、write、unlink等。
2. FIFO严格遵循先进先出。
3. 不支持诸如lseek()等文件定位操作。

//进行1，写操作
int fd = open("my_fifo", O_WRONLY);  
​
char send[100] = "Hello Mike";
write(fd, send, strlen(send));
​
//进程2，读操作
int fd = open("my_fifo", O_RDONLY);//等着只写  
​
char recv[100] = { 0 };
//读数据，命名管道没数据时会阻塞，有数据时就取出来  
read(fd, recv, sizeof(recv));
printf("read from my_fifo buf=[%s]\n", recv);

有名管道注意事项

1. 一个为只读而打开一个管道的进程会阻塞直到另外一个进程为只写打开该管道
2. 一个为只写而打开一个管道的进程会阻塞直到另外一个进程为只读打开该管道

读管道：
Ø 管道中有数据，read返回实际读到的字节数。
Ø 管道中无数据：
u 管道写端被全部关闭，read返回0 (相当于读到文件结尾)
u 写端没有全部被关闭，read阻塞等待
写管道：
Ø 管道读端全部被关闭， 进程异常终止(也可使用捕捉SIGPIPE信号，使进程终止)
Ø 管道读端没有全部关闭：
u 管道已满，write阻塞。
u 管道未满，write将数据写入，并返回实际写入的字节数。

共享存储映射

1. 存储映射I/O (Memory-mapped I/O) 使一个磁盘文件与内存中的一个缓冲区相映射。
2. 从缓冲区读写就相当于从磁盘文件读写（这样可以不使用read&write函数通过地址（指针）完成I/O操作）
3. 共享内存是最有用最快的IPC形式（进程直接读写内存，不需要任何数据拷贝）
   

存储映射函数

1. mmap函数

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

   关于mmap函数的使用总结：
   1) 第一个参数写成NULL
   2) 第二个参数要映射的文件大小 > 0
   3) 第三个参数：PROT_READ 、PROT_WRITE
   4) 第四个参数：MAP_SHARED 或者MAP_PRIVATE
   5) 第五个参数：打开的文件对应的文件描述符
   6) 第六个参数：4k的整数倍，通常为0
2. munmap函数

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

注意事项

1. 创建映射区的过程中，隐含着一次对映射文件的读操作。
2. 当MAP_SHARED时，要求：映射区的权限应 **<=**文件打开的权限(出于对映射区的保护)。而MAP_PRIVATE则无所谓，因为mmap中的权限是对内存的限制。
3. 映射区释放与文件关闭无关。只要映射建立成功，文件可以立即关闭。
4. 特别注意，当映射文件大小为0时，不能创建映射区。所以，用于映射的文件必须要有实际大小。mmap使用时常常会出现总线错误，通常是由于共享文件存储空间大小引起的。
5. munmap传入的地址一定是mmap的返回地址。坚决杜绝指针++操作。
6. 文件偏移量必为4K的整数倍。
7. mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。

共享映射方式操作文件

    int fd = open("xxx.txt", O_RDWR); //读写文件
    int len = lseek(fd, 0, SEEK_END);   //获取文件大小
​
    //一个文件映射到内存，ptr指向此内存
    void * ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (ptr == MAP_FAILED)
    {
        perror("mmap error");
        exit(1);
    }
​
    close(fd); //关闭文件
​
    char buf[4096];
    printf("buf = %s\n", (char*)ptr); // 从内存中读数据，等价于从文件中读取内容
​
    strcpy((char*)ptr, "this is a test");//写内容
​
    int ret = munmap(ptr, len);
    if (ret == -1)
    {
        perror("munmap error");
        exit(1);
    }

共享映射实现父子进程通信

    int fd = open("xxx.txt", O_RDWR);// 打开一个文件
    int len = lseek(fd, 0, SEEK_END);//获取文件大小
​
    // 创建内存映射区
    void *ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (ptr == MAP_FAILED)
    {
        perror("mmap error");
        exit(1);
    }
    close(fd); //关闭文件
​
    // 创建子进程
    pid_t pid = fork();
    if (pid == 0) //子进程
    {
        sleep(1); //演示，保证父进程先执行
​
        // 读数据
        printf("%s\n", (char*)ptr);
    }
    else if (pid > 0) //父进程
    {
        // 写数据
        strcpy((char*)ptr, "i am u father!!");
​
        // 回收子进程资源
        wait(NULL);
    }
​
    // 释放内存映射区
    int ret = munmap(ptr, len);
    if (ret == -1)
    {
        perror("munmap error");
        exit(1);
    }

匿名映射实现父子进程通信

映射区来完成文件读写操作十分方便，缺点：
1.创建映射区一定要依赖一个文件才能实现；
2.建立映射区要open一个temp文件，创建好了再unlink、close掉。

Linux系统提供创建匿名映射区可解决上述问题。无需依赖一个文件即可创建映射区。同样需要借助标志位参数flags来指定。

使用MAP_ANONYMOUS (或MAP_ANON)。

int *p = mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);

注：

1. 4为随意举例，该位置表示映射区大小，可依实际需要填写。
2. MAP_ANONYMOUS和MAP_ANON这两个宏是Linux操作系统特有的宏。在类Unix系统中如无该宏定义，可使用如下两步来完成匿名映射区的建立。

   // 创建匿名内存映射区
       int len = 4096;
       void *ptr = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
       if (ptr == MAP_FAILED)
       {
           perror("mmap error");
           exit(1);
       }
   ​
       // 创建子进程
       pid_t pid = fork();
       if (pid > 0) //父进程
       {
           // 写数据
           strcpy((char*)ptr, "hello mike!!");
           // 回收
           wait(NULL);
       }
       else if (pid == 0)//子进程
       {
           sleep(1);
           // 读数据
           printf("%s\n", (char*)ptr);
       }
   ​
       // 释放内存映射区
       int ret = munmap(ptr, len);
       if (ret == -1)
       {
           perror("munmap error");
           exit(1);
       }