linux应用编程之基于文件的IPC（匿名管道pipe，命名管道mkfifo,普通文件，socket文件）

已于 2022-02-12 20:11:06 修改
阅读量387 收藏
点赞数
分类专栏： Linux应用编程 文章标签： linux 运维 服务器 嵌入式
于 2021-12-31 09:17:06 首次发布
原文链接：https://wlink.blog.csdn.net/article/details/78431018
版权

常用的IPC分为两个类别，一是基于文件，而是基于内存
基于文件的分别有匿名管道，有名管道，普通的文件共享，socket文件
基于内存的有普通内存共享（本文章没有介绍），共享内存，共享信号量，消息队列
如果要看基于内存的IPC，请参考：http://blog.csdn.net/xiaoxiaopengbo/article/details/78431042
本文就针对linux基于文件的IPC

一.匿名管道pipe

管道是一种最基本的IPC机制，作用于有血缘关系的进程之间，完成数据传递。调用pipe系统函数即可创建一个管道。有如下特质：

  1. 其本质是一个伪文件(实为内核缓冲区)
  2. 由两个文件描述符引用，一个表示读端，一个表示写端。
  3. 规定数据从管道的写端流入管道，从读端流出。

管道的原理: 管道实为内核使用环形队列机制，借助内核缓冲区(4k)实现。

管道的局限性：
1） 数据一旦被读走，便不在管道中存在，不可反复读取。
2） 由于管道采用半双工通信方式。因此，数据只能在一个方向上流动。
3）只能在有公共祖先的进程间使用管道。

**常见的通信方式有：**单工通信、半双工通信、全双工通信。

函数原形
#include <unistd.h>

int pipe(int pipefd[2]);

返回值
成功：0；失败：-1，设置errno

Pipefd参数是一个入参，函数调用成功返回r/w两个文件描述符。无需open，但需手动close。规定：fd[0]→ r； fd[1] → w，就像0对应标准输入，1对应标准输出一样。向管道文件读写数据其实是在读写内核缓冲区。

有记下几种编程模型：单进程半双工，父子进程半双工
下图是单进程的半双工编程模型，并附带程序源码
在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
int main()
{
    intfd[2];
    intr;
    charbuf[40];
    printf("%d\n",getpid());
    r=pipe(fd);
    write(fd[1],"hello",5);
    write(fd[1],"world",5);
    
    r=read(fd[0],buf,20);
    buf[r]=0;
    printf("1::%s\n",buf);
    write(fd[1],"Iam writing to pipe",strlen("I am writing to pipe"));
    r=read(fd[0],buf,20);
    buf[r]=0;
    printf("2::%s\n",buf);
    
    r=read(fd[0],buf,20);
    buf[r]=0;
    printf("3::%s\n",buf);
    
    while(1);
}

执行结果
在这里插入图片描述

结论：此程序证明了第一点局限数据一旦被读走，便不在管道中存在，不可反复读取。但是这种编程模型基本没有用途

下面来看看另外一种编程模型，父子进程之前的半双工，同样源码如下
在这里插入图片描述

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
 
int main(void)
{
    int    n;
    int    fd[2];
    pid_t  pid;
    char   line[20]={0};
 
    if(pipe(fd) < 0)
       printf("pipeerr:%m\n");
    if((pid = fork()) < 0) {
       printf("forkerr:%m\n");
    }else if (pid > 0) {       /* parent */
       close(fd[0]);
       write(fd[1],"hello world\n", 12);
    }else {                 /* child */
       close(fd[1]);
       n= read(fd[0], line, 20);
       printf("%s\n",line);
    }
    exit(0);
}

运行结果
在这里插入图片描述

二.有名管道FIFO

上面的匿名管道的缺点其实是很明显的，虽然可以进程间通信，但是只局限于有血缘关系的进程间通信，但是如果我想两个独立的进程用管道来通信呢？有名管道FIFO就有了用武的地方了
创建有名管道函数原形

函数原型：
#include <sys/types.h>
#include <sys/stat.h>

*int mkfifo(const char pathname, mode_tmode);

返回值
返回值 成功：0；失败：-1，设置errno

程序源码：
创建两个文件fifoA.c fifoB.c分别编译为A,B

fifoA.c

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <signal.h>
#include <stdlib.h>
int fd;
int i=0;
void end(int s)
{
    printf("catchctrl+c signal\n");
    //closepipe
    close(fd);
    //deletepipe
    unlink("my.pipe");
    exit(-1);
}
int main()
{
    signal(SIGINT,end);
    //createpipe file
    mkfifo("my.pipe",0666);
    //openpipe file
    fd=open("my.pipe",O_RDWR);
    //writedata per 1 sec
    while(1)
    {
       sleep(1);
       write(fd,&i,4);
       i++;
    }   
}

fifoB.c

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/stat.h>
#include <signal.h>
#include <stdlib.h>
int fd;
int i;
void end(int s)
{
    printf("catchctrl+c signal\n");
    //closepipe
    close(fd);
    exit(-1);
    
}
int main()
{
    signal(SIGINT,end);
    //openpipe file
    fd=open("my.pipe",O_RDWR);
    //readdata
    while(1)
    {
       read(fd,&i,4);
       printf("%d\n",i);
    }
}

先运行fifoA.c的程序，发现就会创建一个
在这里插入图片描述
此时运行B程序，发现数据并没有丢失，一下会把之前的都打印出来
另外需要注意的是：FIFO和pipe一样，数据不会重复读出

三.基于文件共享的IPC

函数原型：
#include <sys/mman.h>
#include <fcntl.h>

// 开启映射
void *mmap(void *start, size_t length, int prot, int flags, int fd, off_t offset);

// 关闭映射
int munmap(void *start, size_t length);

函数形参含义：

*start: 指向欲映射的内存起始地址，通常设为 NULL，表示让系统自动选定地址，映射成功后返回该地址
length: 表示将文件中多大的部分映射到内存，即映射区的长度
prot: 映射区域的保护方式，不能与文件的打开模式冲突。可以为以下一种或几种方式，多种方式使用 or 组合（"|"）

PROT_EXEC: 映射区域可被执行
PROT_READ: 映射区域可被读取
PROT_WRITE: 映射区域可被写入
PROT_NONE: 映射区域不能存取
flags: 影响映射区域的各种特性，指定映射对象的类型，映射选项和映射页是否可以共享。在调用 mmap() 时必须要指定 MAP_SHARED 或 MAP_PRIVATE，flags 可以是以下一个或者多个值：

MAP_FIXED: 如果参数 start 所指的地址无法成功建立映射时，则放弃映射，不对地址做修正。通常不鼓励这样设置
MAP_SHARED: 对映射区域的写入数据会复制回文件内，而且允许其他映射该文件的进程共享。与其它所有映射这个对象的进程共享映射空间。对共享区的写入，相当于输出到文件。直到 msync() 或者 munmap() 被调用，文件实际上不会被更新
MAP_PRIVATE: 对映射区域的写入操作会产生一个映射文件的复制，即私人的“写入时复制”（copy on write）对此区域作的任何修改都不会写回原来的文件内容，写入不会影响到原文件。这个标志和 MAP_SHARED 是互斥的，只能使用其中之一
MAP_ANONYMOUS: 建立匿名映射。此时会忽略参数fd，不涉及文件，而且映射区域无法和其他进程共享。
MAP_DENYWRITE: 只允许对映射区域的写入操作，其他对文件直接写入的操作将会被拒绝
MAP_LOCKED: 将映射区域锁定住，这表示该区域不会被置换（swap），从而防止页面被交换出内存
MAP_NORESERVE: 不为这个映射保留交换空间。当交换空间被保留，对映射区修改的可能会得到保证。当交换空间不被保留，同时内存不足，对映射区的修改会引起段违例信号
MAP_LOCKED: 锁定映射区的页面，从而防止页面被交换出内存
MAP_GROWSDOWN: 用于堆栈，告诉内核 VM 系统，映射区可以向下扩展
MAP_POPULATE: 为文件映射通过预读的方式准备好页表。随后对映射区的访问不会被页违例阻塞
MAP_NONBLOCK: 仅和 MAP_POPULATE 一起使用时才有意义。不执行预读，只为已存在于内存中的页面建立页表入口
fd: 要映射到内存中的文件描述符

offset: 文件映射的偏移量，通常设置为 0，表示从文件起始位置对应，offset 必须是 page size 的整数倍

返回值：
若映射成功，mmap() 返回映射区的内存起始地址，munmap() 返回 0
若映射失败，mmap() 返回 MAP_FAILED，其值为(void *)-1，munmap() 返回 -1

源码：
分别有procA.c procB.c，分别编译成A,B可以执行程序

ProcA.c

#include <stdio.h>
#include <fcntl.h>
#include <sys/mman.h>
main()
{
    int*p;
    intfd;
    inti;
    fd=open("tmp",O_RDWR|O_CREAT,0666);
    ftruncate(fd,4);
    p=mmap(0,4,PROT_READ|PROT_WRITE,
           MAP_SHARED,fd,0);
    i=0;       
    while(1)
    {
       sleep(1);
       *p=i;
       i++;
    }
    close(fd);
}

ProcB.c

#include <stdio.h>
#include <fcntl.h>e
#include <sys/mman.h>
main()
{
    int*p;
    intfd;    
    fd=open("tmp",O_RDWR);   
    p=mmap(0,4,PROT_READ|PROT_WRITE,
           MAP_SHARED,fd,0);
    while(1)
    {
       sleep(1);
       printf("%d\n",*p);
    }
    close(fd);
}

运行结果

A程序每隔1s写一次数，写的数每次+1
运行B程序如图
在这里插入图片描述
发现还是结果会丢失的

四.socket文件的IPC

socket网络编程可能使用得最多，经常用在网络上不同主机之间的通信。其实在同一主机内通信也可以使用socket来完成，socket进程通信与网络通信使用的是统一套接口，只是地址结构与某些参数不同。在使用socket创建套接字时通过指定参数domain是af_inet（ipv4因特网域）或af_inet6（ipv6因特网域）或af_unix（unix域）来实现。

函数原型：
#include <sys/types.h> /* See NOTES */
#include <sys/socket.h>

int socket(int domain, int type, intprotocol);

第一个参数demain是协议簇
Name                Purpose                          Man page

AF_UNIX, AF_LOCAL   Local communication              unix(7)

AF_INET             IPv4 Internet protocols          ip(7)

AF_INET6            IPv6 Internet protocols          ipv6(7)

AF_IPX              IPX - Novell protocols

AF_NETLINK          Kernel user interface device     netlink(7)

AF_X25              ITU-T X.25 / ISO-8208protocol   x25(7)

AF_AX25             Amateur radio AX.25 protocol

AF_ATMPVC           Access to raw ATM PVCs

AF_APPLETALK        Appletalk                        ddp(7)

AF_PACKET           Low level packet interface       packet(7)

一般常用的就是前三个

Type参数有以下几个选择

SOCK_STREAM     Provides sequenced, reliable, two-way,connection-based

                       byte  streams. An out-of-band data transmission mecha‐

                       nism may be supported.

SOCK_DGRAM      Supports datagrams (connectionless,unreliable messages

                       of a fixed maximumlength).

SOCK_SEQPACKET  Provides a  sequenced,  reliable, two-way connection-

                       based data transmissionpath  for datagrams  of  fixed

                       maximum  length; a  consumer  is required  to read  anentire packet with each input system call.

SOCK_RAW        Provides raw network protocol access.

SOCK_RDM        Provides a reliable datagram layer thatdoes not  guar‐antee ordering.

 

SOCK_PACKET     Obsolete and  should  not be used in new programs; see packet(7).

第三个参数很少用，一般通过前两个参数就能确定要传输的协议，我通常都设为0

返回值
成功：返回文件描述符；失败：-1，设置errno

源码：
直接贴两个进程间通讯的
socketA.c socketB.c

socketA.c

#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <linux/un.h>
 
int main()
{
    intfd;
    intr;
    charbuf[200];
    //1.建立socket
    fd=socket(AF_UNIX,SOCK_DGRAM,0);
    if(fd==-1)printf("socketerr:%m\n"),exit(-1);
    printf("socket成功\n");
    //2.构造本地文件地址
    structsockaddr_un addr={0};
    addr.sun_family=AF_UNIX;
    memcpy(addr.sun_path,"my.sock",strlen("my.sock"));
    //3.把socket绑定在地址上
    r=bind(fd,(structsockaddr*)&addr,sizeof(addr));
    if(r==-1)printf("binderr:%m\n"),exit(-1);
    printf("地址绑定成功\n");
    //4.接受数据
    bzero(buf,sizeof(buf));
    r=read(fd,buf,sizeof(buf));
    printf("%s\n",buf);
    //5.关闭通道
    close(fd);
    //6.删除socket文件
    unlink("my.sock");
}

socketB.c

#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <linux/un.h>
 
int main()
{
    intfd;
    intr;
    charbuf[200];
    structsockaddr_un addr={0};
    //1.建立socket
    fd=socket(AF_UNIX,SOCK_DGRAM,0);
    if(fd==-1)printf("socketerr:%m\n"),exit(-1);
    printf("socket成功\n");
    //2.链接到指定地址
    addr.sun_family=AF_UNIX;
    memcpy(addr.sun_path,"my.sock",strlen("my.sock"));
    r=connect(fd,(structsockaddr*)&addr,sizeof(addr));
    if(r==-1)printf("binderr:%m\n"),exit(-1);
    printf("地址连接成功\n");
    //3.发送数据
    write(fd,"hello!",strlen("hello"));
 
    //4.关闭通道
    close(fd);
}

运行结果
在这里插入图片描述

下面举一个网络通信的socket，编程模型是一致的，ipA.c ipB.c

ipA.c

#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <linux/un.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int main()
{
    intfd;
    intr;
    charbuf[200];
    //1.建立socket
    fd=socket(AF_INET,SOCK_DGRAM,0);
    if(fd==-1)printf("socketerr:%m\n"),exit(-1);
    printf("socket成功\n");
    //2.构造本地文件地址
    structsockaddr_in addr={0};
    addr.sin_family=AF_INET;
    addr.sin_port=htons(9999);
    addr.sin_addr.s_addr=inet_addr("192.168.1.102");
    //3.把socket绑定在地址上
    r=bind(fd,(structsockaddr*)&addr,sizeof(addr));
    if(r==-1)printf("binderr:%m\n"),exit(-1);
    printf("地址绑定成功\n");
    //4.接受数据
    bzero(buf,sizeof(buf));
    r=read(fd,buf,sizeof(buf));
    printf("%s\n",buf);
    //5.关闭通道
    close(fd);
    //6.删除socket文件 
}

ipB.c

#include <sys/socket.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <linux/un.h>
#include <netinet/in.h>
#include <arpa/inet.h>
int main()
{
    intfd;
    intr;
    charbuf[200];
    //1.建立socket
    fd=socket(AF_INET,SOCK_DGRAM,0);
    if(fd==-1)printf("socketerr:%m\n"),exit(-1);
    printf("socket成功\n");
    //2.构造本地文件地址
    structsockaddr_in addr={0};
    addr.sin_family=AF_INET;
    addr.sin_port=htons(9999);
    addr.sin_addr.s_addr=inet_addr("192.168.1.102");
    //3.把socket绑定在地址上
    r=connect(fd,(structsockaddr*)&addr,sizeof(addr));
    if(r==-1)printf("binderr:%m\n"),exit(-1);
    printf("地址绑定成功\n");
    //4.接受数据
    write(fd,"hello!",strlen("hello"));
    //5.关闭通道
    close(fd);
    //6.删除socket文件
}

运行结果是和上面的类似的

路过的小熊~
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux-IPC
Musing的博客
10-19 304
目录 1.Linux进程间通信方法 2. 管道 2.1 shell中的管道 2.2 无名管道 编程 2.3 无名管道代码 2.4有名管道 2.5关于fork函数 fork（函数） 3. 消息队列 4. 信号量 5. 共享内存 6.线程 6.1 线程函数 互斥量的操作函数 读写锁 条件变量 自旋锁 1.Linux进程间通信方法 管道 有名管道 消息...
allegro出gerber文件、ipc文件、钻孔文件教程，这个要是再学不会真是就没有办法了。
08-10
Allegro详细出gerber说明，包括钻孔文件、ipc文件导出设置。提供给板厂的.ipc、钻孔文件、gerber文件等设置。
Linux——IPC 基于文件的通信（普通文件 管道文件）
宁静致远
09-16 1245
二.IPC 用信号来进行进程之间传递信号 不适合大量数据传递         1.基于文件                 1.1.无序文件                 1.1.有序文件                         1.1.1.管道                                 1.1.1.1.有名                     
Windows IPC
最新发布
hide_in_darkness的博客
05-16 514
IPC 的个人理解
linux下ipc是什么目录,Linux IPC入门基础知识
weixin_42558257的博客
04-29 370
简介IPC 主要有消息队列、信号量和共享内存3种机制。和文件一样，IPC 在使用前必须先创建，使用 ipcs 命令可以查看当前系统正在使用的 IPC 工具:由以上可以看出，一个 IPC 至少包含 key值、ID值、拥有者、权限和使用的大小等关键信息。如果需要手工删除某个 IPC 机制，可以使用 ipcrm 命令。key 值和 ID 值IPC 在实现时编写使用 key 值作为参数创建，如果在创建时使...
14----基于socket文件的IPC
u014304293的专栏
09-05 902
两种模型：
fifo.zip_Linux/Unix编程
09-24
标题“fifo.zip_Linux/Unix编程”提示我们，这个压缩包可能包含的是关于如何在这些系统中进行管道编程的资料。描述中的“可作为参考”意味着这可能是一个学习或教程性质的资源，帮助开发者理解和使用管道。 管道的...
Linux-IPC-进程间通信实例
12-15
在Linux中，可以使用`pipe()`函数创建管道，然后通过`fork()`创建子进程，使得父子进程之间可以通过管道传递信息。例如，父进程向管道写入数据，子进程从管道读取数据。 2. **共享内存（Shared Memory）**： 共享...
Linux网络编程（Socket技术）
05-25
### Linux网络编程（Socket技术） #### 一、网络编程概览 **1.1 网络的历史** 网络的历史可以追溯到20世纪60年代，最初是为了解决军事和科研领域的需求而发展起来的。随着时间的推移，网络技术逐渐普及到了商业和...
jincheng.zip_管道通信
09-22
在Windows系统中，命名管道通常使用CreateFile函数创建，而在Unix/Linux系统中，可以通过mkfifo命令或mknod函数创建。通信时，一个进程作为服务器端监听管道，另一个进程作为客户端发送或接收数据。 4. **油槽通信...
Linux进程间管道通信的研究
01-26
Linux作为一种开放源代码的操作系统，在IPC方面提供了丰富的机制，包括信号(signal)、管道(pipe)、信号量(semaphore)、消息队列(message queue)、共享内存(shared memory)以及套接字(socket)等。其中，管道通信是最...
mkfifo命令 创建FIFO文件
01-09
使用mkfifo命令可以使用指定的名称创建先进先出文件（FIFO） 语法格式：mkfifo [参数] [名称] 常用参数： -m 设置权限模式，类似chmod -Z 将每个创建的目录SELinux安全环境设置为CTX 参考实例 创建FIFO文件 /root/fifo： [root@linuxcool ~]# mkfifo /root/fifo 与该功能相关的Linux命令：xzless命令 – 查看xz压缩文本文件find2perl命令 – 转换找到的命令行为perl代码diff3命令 – 比较3个文件的不同之处zcat命令 – 查看压缩文件的内容mysqldump命令 –
Linux进程间通信(IPC)
weixin_42581560的博客
01-02 565
Linux进程间通信，主要介绍了管道，命名管道，信号量，共享内存，消息队列
进程间通信（匿名管道、命名管道、消息队列、共享内存、信号量、信号、Socket）
m0_61227789的博客
10-26 282
本文主要介绍了进程间通信的几种方式，包括匿名管道，命名管道，消息队列，共享内存，信号量，信号，Socket
Linux学习通信阶段中 pipe mkfifo API相关介绍
m0_52983689的博客
02-20 134
无名管道 #include <unistd.h> int pipe(int fd[2]); pipefd:当一个管道建立时,它会创建两个文件描述符:fd[0]为读而打开,fd[1]为写而打开 返回值:成功返回0,否则返回-1 #include <stdio.h> #include <unistd.h> #include <string.h> #include <stdlib.h> int main() { //int pip
Linux下IPC方法-内存映射区（一）文件进程间通信
linkvivi的博客
04-06 436
1、使用文件进行进程间通信的理论依据是，fork之后，父子进程共享打开文件的文件描述符；也就是共享打开的文件。2、父子进程通过文件进行进程间通信：//父子进程共享打开的文件描述符，使用文件进行进程间通信 #include&lt;stdio.h&gt; #include&lt;unistd.h&gt; #include&lt;string.h&gt; #include&lt;stdlib.h&gt;...
进程通信（信号量、匿名管道、命名管道、Socket）
10-02 279
转自：操作系统-进程通信（信号量、匿名管道、命名管道、Socket） - yocichen - 博客园 具体的概念就没必要说了，参考以下链接。 信号量 匿名管道 命名管道 Socket Source Code： 1. 信号量（生产者消费者问题） 1 #include <iostream> 2 #include <Windows.h> 3 #include <process.h> 4 #include <vector> 5 usi.
linux进程间通信程-pipe、mkfifo、…
11-18 1136
进程间通信概述： 目的： 1、数据传输：一个进程需要将它的数据发送给另一个进程。 2、资源共享：多个进程之间共享同样的资源。 3、通知事件：一个进程需要向另一个或一组进程发送消息，通知它们发生了某种事件。 4、进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有操作，并能够及时知道它的状态改变。 linux进程间通信（IPC）由以下几个部分
进程间通信（IPC）之-----------文件
小吕的博客
06-13 387
1、 linux 环境中进程地址空间相互独立，每个进程各自有不同的用户地址空间 任何一个进程的全局变量在另一个进程都是不可见的，进程与进程之间不可以相互访问，所以需要内核来进行数据交换。 在内核中开辟数据缓存区，进程1把数据从用户空间拷贝到内核缓存区，进程2再从内核缓存区把数据取走 比方说我有两个进程 a.out b.out 我如果在A中打开一个文件我可以通过文件描述符来操作 A B中文件描述符是可以不相等的这取决于当前进程中文件描述符的使用情况 0 1 2错误输入输出这几个是一般...
Linux系统编程：fifo有名管道在高频金融交易中的应用
"Linux系统编程，有名管道(fifo)，中间件，高频金融交易数据接收，网络编程，Socket" 本文主要探讨的是Linux系统编程中的有名管道（fifo）技术，并将其应用于高频金融交易数据的接收场景。有名管道是Linux提供的一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值