1. 进程间通信

1.1. 进程间通信的目的

1.2. 如何实现进程间通信

2. 管道通信

2.1. 匿名管道

2.1.1 创建匿名管道

2.1.2 . 深入理解匿名管道

2.2. 命名管道

2.2.1. 创建命名管道

3. system V 标准进程间通信

3.1. 共享内存

3.1.1. 实现原理

3.1.2. 代码实现

3.2. 消息队列(了解)

3.2.1 实现原理

3.3. 信号量(了解)

3.3.1. 实现原理

1. 进程间通信

1.1. 进程间通信的目的

进程之间可能会存在特定的协同工作的场景，而协同就必须要进行进程间通信，协同工作可能有以下场景。

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

资源共享：多个进程之间共享同样的资源。

通知事件：一个进程需要向另一个或一组进程发送消息，通知它发生了某种事件。

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

1.2. 如何实现进程间通信

由于一个进程是不能访问到另一个进程的资源的，即进程之前是具有独立性的。

那么进程之间要通信，就不能使用属于进程的资源，而应该使用一份公共的资源。

所以进程间通信的本质是：由OS参与，提供一份所以进程都能访问的公共资源。

而公共资源是什么，例如：文件、队列、内存块。

2. 管道通信

2.1. 匿名管道

适用场景：父子进程间通信。

基本原理：通过打开同一个文件，父子进程对文件进行读写操作，父子进程在文件内核缓冲区中写入或读出数据，从而实现通信。

2.1.1 创建匿名管道

使用接口

pipe：创建一个管道，参数为输出型参数，打开两个文件描述符(fd)，返回值为0表示打开失败。

具体代码：

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>int main()
{int pipefd[2] = {0};if(pipe(pipefd) != 0){perror("pipe");return 1;}// 父进程读取数据，子进程写入数据// 规定：pipedfd[0]为读取端，pipefd[1]为写入端if(fork() == 0){//childclose(pipefd[0]);// 关闭读取端const char* msg = "hello world\n";while(1){write(pipefd[1], msg, strlen(msg));sleep(1);}exit(0);}// fatherclose(pipefd[1]);// 关闭写入端while(1){char buffer[64] = {0};ssize_t s = read(pipefd[0], buffer, sizeof(buffer));// 如果read的返回值是0，表示子进程关闭了文件描述符if(s == 0){printf("child quit\n");break;}else if(s > 0){buffer[s] = 0;// 子进程写入时没有添加'\0'，需要手动添加printf("child say：%s",buffer);}else{printf("read error\n");break;}}return 0;
}

子进程写入数据，父进程读出数据，这样就实现了简单的父子进程间的通信：

问题分析：为什么上面的代码中，需保证读端比写端快？

因为管道是面向字节流的，字符串之间没由规矩分隔符，如果读取速度慢于写入速度，可能读端还没有将整个字符串读完，写端又写入了数据，会导致数据混乱。

2.1.2 . 深入理解匿名管道

匿名管道的五个特点：

只能单向通信的信道

面向字节流

只能在父子进程间通信

管道自带同步机制，原子性写入

管道也是文件，管道的生命周期随进程

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>int main()
{int pipefd[2] = {0};if(pipe(pipefd) != 0){perror("pipe");return 1;}if(fork() == 0){//childclose(pipefd[0]);// 关闭读取端int count = 0;char c = 'a';while(1){write(pipefd[1], &c, 1);count++;printf("%d\n", count);}exit(0);}// fatherclose(pipefd[1]);// 关闭写入端while(1){sleep(5);char buffer[4*1024+1] = {0};ssize_t s = read(pipefd[0], buffer, sizeof(buffer)-1);buffer[s] = 0;printf("father take：%s\n", buffer);}return 0;
}

云服务器中，管道的大小为64KB，写端写满后不会再写，会等读端读取管道内容，且读取4KB后才会重新写入（读端的容量为4KB）。

管道读写规则

当没有数据可读时

O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。 O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。

当管道满的时候

O_NONBLOCK disable： write调用阻塞，直到有进程读走数据

O_NONBLOCK enable：调用返回-1，errno值为EAGAIN

如果所有管道写端对应的文件描述符被关闭，则read返回0 如果所有管道读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE,进而可能导致write进程退出

当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。

当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。

即匿名管道的四种情况：

读端不读或读的慢，写端要等读端

读端关闭，写端收到SIGPIPE信号直接终止

写端不写或者写的慢，读端要等写端

写端关闭，读端会读完管道内的数据然后再读，会读到0，表示读道文件结尾

2.2. 命名管道

为了解决匿名管道只能在父子进程间通信的缺陷，引入了命名管道。

其性质除了能让任意进程间通信外，与匿名管道基本一致，即创建一个文件一个进程往文件中写数据，一个进程读数据，且不让文件内容刷新到磁盘上，从而实现任意进程间的通信。

2.2.1. 创建命名管道

命令行创建

使用命令 mkfifo 管道

然后使用一个简单的shell脚本，将 hello world 每间隔一秒输入到管道中，然后另一边读取管道中的内容。

通过这种方式，显示不是重点。

代码创建

使用接口：mkfifo

因为是不同进程间的通信，所以这里需要创建两个进程：

comm.h

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

#define MY_FIFO "./fifo"

server.c

#include"comm.h"
int main()
{umask(0);if(mkfifo(MY_FIFO, 0666) < 0) //创建命名管道{perror("mkfifo");return 1;}
// 只需要文件操作即可int fd = open(MY_FIFO, O_RDONLY);if(fd < 0){perror("open");return 2;}
// 业务逻辑while(1){char buffer[64] = {0};ssize_t s = read(fd, buffer, sizeof(buffer)-1);if(s > 0){buffer[s] = 0;printf("client-> %s\n", buffer);}else if(s == 0){printf("client quit...\n");break;}else{perror("read");break;}}
close(fd);return 0;
}

client.c

#include"comm.h"


int main()
{int fd = open(MY_FIFO, O_WRONLY);if(fd < 0){perror("open");return 1;}
// 业务逻辑while(1){printf("请输入-> ");fflush(stdout);char buffer[64] = {0};ssize_t s = read(0, buffer, sizeof(buffer)-1); // 从显示器上读取数据，然后写入到文件中if(s > 0){buffer[s-1] = 0;printf("%s\n", buffer);write(fd, buffer, strlen(buffer));}}return 0;
}

运行起来后，就实现了简单的命名管道的通信：

为什么命名管道有名字，而匿名管道没有？

命名管道有名字是为了保证让不同进程看到同一个文件。

匿名管道没有名字，是因为他是通过父子继承放入方式，看到同一份资源不需要名字。

3. system V 标准进程间通信

system V：同一主机内的进程间通信方案，在OS层面专门为进程间通信设计的方案

进程间通信的本质：让不同的进程看到同一份资源

system V标准下的三种通信方式

共享内存

消息队列

信号量

3.1. 共享内存

3.1.1. 实现原理

通过系统调用，在内存中创建一份内存空间

通过系统调用，让进程"挂接"到这份新开辟的内存空间上(即在页表上建立虚拟地址与物理地址的映射关系)

去关联(挂接)

释放共享内存

使用接口：

shmget：申请共享内存

#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);
// key：创建共享内存时的算法和数据结构中唯一标识符，由用户自己设定需用到接口ftok
// size：共享内存的大小，建议是4KB的整数倍
// shmflg：有两个选项：IPC_CREAT(0)，创建一个共享内存，如果已经存在则返回共享内存；IPC_EXCL(单独使用没有意义)
// IPC_CREAT|IPC_EXCL(如果调用成功，一定会得到一个全新的共享内存)：如果不存在共享内存，就创建；反之，返回出错
// 返回值：shmdi，描述共享内存的标识符
#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id); // 算法生成key
// pathname：自定义路径名
// proj_id：自定义项目id

shmctl：控制共享内存

#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
// shmid：共享内存id
// cmd：控制方式，这里我们只使用IPC_RMID 选项，表示删除共享内存
// buf：描述共享内存的数据结构

struct_shmid_ds结构体：

shmat、shmdt：关联、去关联共享内存

#include <sys/types.h>
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg); // 关联
// shmid：共享内存id
// shmaddr：挂接地址(自己不知道地址，所以默认为NULL)
// shmflg：挂接方式，默认为0
// 返回值：挂接成功返回共享内存起始地址(虚拟地址)，类似C语言malloc
int shmdt(const void *shmaddr); // 去关联(取消当前进程和共享内存的关系)
// shmaddr：去关联内存地址，即shmat返回值
// 返回值：调用成功返回0，失败返回-1

命令行查看共享内存：

ipcs -m // ipcs 查看ipc资源

system V 的IPC资源，生命周期随内核，只能通过程序员显示释放(或者OS重启)

命令行删除共享内存方法：

ipcrm -m shmid

3.1.2. 代码实现

comm.h

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

#define PATH_NAME "./"
#define PROJ_ID 0x6666
#define SIZE 4096

server.c

#include"comm.h"

int main()
{key_t key = ftok(PATH_NAME, PROJ_ID);if(key < 0){perror("ftok");return 1;}printf("key-> %x\n", key);
int shmid = shmget(key, SIZE, IPC_CREAT|IPC_EXCL|0666); // 创建全新共享内存if(shmid < 0){perror("shmget");return 1;}printf("shmid-> %d\n", shmid);
char* mem = (char*)shmat(shmid, NULL, 0);// 通信逻辑while(1){printf("%s\n", mem);// 打印mem内存中的内容sleep(1); }
shmdt(mem);
shmctl(shmid, IPC_RMID, NULL);
return 0;
}

client.c

#include"comm.h"

int main()
{key_t key = ftok(PATH_NAME, PROJ_ID);if(key < 0){perror("ftok");return 1;}
int shmid = shmget(key, SIZE, IPC_CREAT);if(shmid < 0){perror("shmget");return 1;}
// 挂接char* mem = (char*)shmat(shmid, NULL, 0);// 通信逻辑char c = 'A';while(c <= 'Z'){mem[c - 'A'] = c;c++;mem[c - 'A'] = 0;sleep(2);}
// 去关联shmdt(mem);
//该共享内存不由client创建，所以不用它删除
return 0;
}

运行结果：

使用共享内存进行通信时，不需要使用read和write 接口。

共享内存是所有进程间通信中速度最快的。

共享内存不提供任何同步或互斥机制，需要程序员自行保证数据安全。

ps: 共享内存在内核中的申请的基本单位是页，内存页的大小为4KB，如果申请4097个字节，内核会分配8KB空间。

3.2. 消息队列(了解)

3.2.1 实现原理

接口类似与共享内存，底层是一个队列结构

msgget：创建消息队列

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgget(key_t key, int msgflg);

msgctl：控制消息队列

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
int msgctl(int msqid, int cmd, struct msqid_ds *buf);

3.3. 信号量(了解)

什么是信号量？

信号量不是以传输数据为目的，通过共享“资源”的方式，来达到多个进程的同步和互斥的目的！

本质是一个计数器，衡量临界资源中的资源数目。

临界资源：同时被多个进程访问的资源。例如：显示器打印，共享内存，消息队列

临界区：用来访问临界资源的代码，就是临界区。

原子性：执行事件时没有中间过程，且操作不可中断，要么执行完，要么没有执行。

互斥：在任意时刻，只允许一个进程进入临界资源。

同步：两个或多个数据库、文件、模块、线程之间用来保持数据内容一致性的机制。

3.3.1. 实现原理

接口类似共享内存

semget：创建信号量

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semget(key_t key, int nsems, int semflg);

semctl：控制信号量

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
int semctl(int semid, int semnum, int cmd, ...);

所有的ipc资源都是通过数组组织起来的。

【Linux】进程间通信相关推荐

linux进程间通信：POSIX 共享内存
文章目录思维导图通信原理优势 POSIX 共享内存编程接口编程案例思维导图之前学习过sysemV 的共享内存的实现及使用原理,参考linux进程间通信:system V 共享内存 POS ...
linux进程间通信：POSIX 消息队列 ----异步通信
在上一篇中linux进程间通信:POSIX 消息队列我们知道消息队列中在消息个数达到了队列所能承载的上限,就会发生消息的写阻塞. 阻塞式的通信影响系统效率,进程之间在通信收到阻塞时并不能去做其他事情, ...
linux进程间通信：POSIX 消息队列
文章目录基本介绍相关编程接口编程实例消息队列通信实例消息队列属性设置实例基本介绍关于消息队列的基本介绍,前面在学习system V的消息队列时已经有过了解,linux进程间通信:syst ...
linux进程间通信：system V 信号量生产者和消费者模型编程案例
生产者和消费者模型: 有若干个缓冲区,生产者不断向里填数据,消费者不断从中取数据两者不冲突的前提: 缓冲区有若干个,且是固定大小,生产者和消费者各有若干个生产者向缓冲区中填数据前需要判断缓冲区是否 ...
Linux进程间通信--进程，信号，管道，消息队列，信号量，共享内存
Linux进程间通信--进程,信号,管道,消息队列,信号量,共享内存参考:<linux编程从入门到精通>,<Linux C程序设计大全>,<unix环境高级编程> ...
Linux进程间通信（二）：信号集函数 sigemptyset()、sigprocmask()、sigpending()、sigsuspend()...
我们已经知道,我们可以通过信号来终止进程,也可以通过信号来在进程间进行通信,程序也可以通过指定信号的关联处理函数来改变信号的默认处理方式,也可以屏蔽某些信号,使其不能传递给进程.那么我们应该如何设定我 ...
20155301 滕树晨linux基础——linux进程间通信（IPC）机制总结
20155301 滕树晨linux基础--linux进程间通信(IPC)机制总结共享内存共享内存是在多个进程之间共享内存区域的一种进程间的通信方式,由IPC为进程创建的一个特殊地址范围,它将出现在 ...
Linux 进程间通信
引言进程通信的目的: 数据传输一个进程需要将它的数据发送给另一个进程,发送的数据量在一个字节到几M字节之间共享数据多个进程想要操作共享数据,一个进程对共享数据通知事一个进程需要向另一个或一 ...
Linux进程间通信中的文件和文件锁
Linux进程间通信中的文件和文件锁来源:穷佐罗的Linux书前言使用文件进行进程间通信应该是最先学会的一种IPC方式.任何编程语言中,文件IO都是很重要的知识,所以使用文件进行进程间通信就成了 ...
linux 进程间通信 dbus-glib【实例】详解四（上） C库 dbus-glib 使用（附代码）（编写接口描述文件.xml，dbus-binding-tool工具生成绑定文件）（列集散集函数）
linux 进程间通信 dbus-glib[实例]详解一(附代码)(d-feet工具使用) linux 进程间通信 dbus-glib[实例]详解二(上) 消息和消息总线(附代码) linux 进程间 ...

【Linux】进程间通信

1. 进程间通信

1.1. 进程间通信的目的

1.2. 如何实现进程间通信

2. 管道通信

2.1. 匿名管道

2.1.1 创建匿名管道

2.1.2 . 深入理解匿名管道

2.2. 命名管道

2.2.1. 创建命名管道

3. system V 标准进程间通信

3.1. 共享内存

3.1.1. 实现原理

3.1.2. 代码实现

3.2. 消息队列(了解)

3.2.1 实现原理

3.3. 信号量(了解)

3.3.1. 实现原理

【Linux】进程间通信相关推荐

最新文章

热门文章