进程间通信目的
- 数据传输：一个进程需要将它的数据发送给另一个进程
- 资源共享：多个进程之间共享同样的资源
- 通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）
- 进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变
进程间通信发展
- 管道
- System V进程间通信
- POSIX进程间通信
进程间通信分类
管道：数据流传输
- 匿名管道
- 命名管道
System V IPC
- System V 消息队列：数据块传输
- System V 共享内存：数据共享
- System V 信号量：实现进程间同步与互斥
POSIX IPC
- 消息队列
- 共享内存
- 信号量
- 互斥量
- 条件变量
- 读写锁
管道
半双工通信方式：提供双向选择，但是只能单向传输
本质（原理）：操作系统在内核中创建一块缓冲区（多个进程只要都能访问到这块缓冲区就可以实现通信）
- 进程1，将数据从用户态缓冲区拷贝到内核态缓冲区
- 进程2，将数据从内核态缓冲区拷贝到用户态缓冲区
- 涉及到两次用户态与内核态之间的数据拷贝
操作：通过IO接口实现管道这个缓冲区的操作
管道的分类：匿名管道和命名管道
- 没有‘名字’，因此只能通过子进程复制父进程的方式（复制了文件描述符）实现通信
- 有‘名字’则可以通过‘名字’打开相同的管道进行通信
匿名管道只能用于具有亲缘关系的进程间通信
命名管道可以用于任意的进程间通信
匿名管道：内核中没有名字的缓冲区
一个进程通过系统调用接口，在内核中创建一块没有明确标识的缓冲区；内核返回给进程两个文件描述符供进程来操作管道；其中一个描述符用于从管道读取数据，另一个向管道中可以写入数据；但是因为匿名管道没有明确标识，意味着其它进程无法找到缓冲区，无法进行通信；因此匿名管道只能用于具有亲缘关系的进程间通信；因为子进程可以通过复制父进程pcb中的文件描述符信息，得到管道的操作句柄。
操作接口：
- pipefd：输出型参数，用于获取管道操作句柄
- pipefd[0]：用于从管道读取数据
- pipefd[1]：用于向管道写入数据
- 返回值：成功：0 失败：-1
读写特性：
- 管道中若没有数据，则read会阻塞；直到数据被写入（缓冲区中有数据）
- 管道中若数据满了，则write会阻塞，直到数据被读取（缓冲区中有空闲空间）
- 若管道的所有读端被关闭，则write会触发异常，SIGPIPE（导致进程退出）
- 若管道的所有写端被关闭，则read会在读完管道中的数据后不再阻塞，返回0
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/wait.h>
int main()
{
// 管道必须创建于子进程之前（子进程这样才能复制到管道的操作句柄）
// int pipe(int pipefd[2]);
int pipefd[2];
int ret = pipe(pipefd);
if (ret < 0)
{
perror("pipe error");
return -1;
}
int pid = fork();
if (pid == 0)
{
// child
// 关闭子进程写端，但是父进程的写端没有关闭，子进程依然可以读取数据
close(pipefd[1]);
char buf[1024] = {0};
// 若所有写端被关闭，则read不再阻塞，读完数据后返回0
// 此时父进程的写端没有被关闭，则缓冲区中没有数据的时候，read会阻塞等待
int ret = read(pipefd[0], buf, sizeof(buf) - 1);
printf("child read buf:[%d-%s]\n", ret, buf);
// 子进程退出
exit(0);
}
else if (pid > 0)
{
// parent
// 让子进程先运行
sleep(1);
//关闭父进程读端，但是子进程的读端没有关闭，父进程依然可以写入数据
close(pipefd[0]);
// 若所有读端被关闭，则write会触发异常，导致进程退出
// 此时子进程的读端没有被关闭，则write可以写入数据
const char* str = "hello world";
write(pipefd[1], str, strlen(str));
}
//等待子进程退出
wait(NULL);
printf("-------------------------\n");
return 0;
}
匿名管道的简单实现：ls -l | grep pipe.c
- ls -l：浏览目录，并且将结果写入到标准输出
- grep pipe.c：从标准输入循环读取数据，对读到的数据进行过滤匹配
匿名管道的实现就是创建两个进程，一个运行ls -l，一个运行grep pipe.c
让ls -l这个进程标准输出重定向到管道写入端
让grep pipe.c这个进程标准输入重定向到管道读写端
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#include <sys/wait.h>
int main()
{
// ls -l | grep pipe.c
int pipefd[2];
int ret = pipe(pipefd);
if (ret < 0)
{
perror("pipe error");
return -1;
}
int pid1 = fork();
if (pid1 == 0)
{
// child
//将标准输出重定向到管道写入端，向1写入数据就相当于向管道写入数据
dup2(pipefd[1], 1);
execlp("ls", "ls", "-l", NULL);
exit(0);
}
int pid2 = fork();
if (pid2 == 0)
{
// grep pipe.c
// 关闭写端，ls -l进程退出后，所有写端就会被关闭
close(pipefd[1]);
//将标准输入重定向到管道读端，从0读取数据就相当于从管道读取数据
dup2(pipefd[0], 0);
execlp("grep", "grep", "pipe.c", NULL);
exit(0);
}
//关闭父进程的读写端
close(pipefd[1]);
close(pipefd[0]);
// 等待子进程退出
waitpid(pid1, NULL, 0);
waitpid(pid2, NULL, 0);
return 0;
}
命名管道：在内核中这块缓冲区是有标识的
所有的进程都可以通过这个标识找到这块缓冲区实现通信。
命名管道的标识实际上是一个文件，可见于文件系统，意味着所有进程都可以通过打开文件进而访问到内核中的缓冲区。
操作接口：
- pathname：管道文件的路径名
- mode：管道文件的权限
- 返回值：成功：0 失败：-1
命名管道的打开特性：
- 若管道文件没有被以写的方式打开，则以只读打开会阻塞；
- 若管道文件没有被以读的方式打开，则以只写打开会阻塞；
命名管道的读写特性：雷同于匿名管道
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/stat.h>
int main()
{
// int mkfifo(const char *pathname, mode_t mode);
// pathname:管道文件名称
// mode:管道文件权限
// 返回值：0 失败：-1
const char* fifo = "./test.fifo";
umask(0);
int ret = mkfifo(fifo, 0664);
if (ret < 0 && errno != EEXIST)
{
perror("mkfifo error");
return -1;
}
int fd = open(fifo, O_RDONLY);
if (fd < 0)
{
perror("open fifo error");
return -1;
}
printf("open fifo success\n");
while (1)
{
char buf[1024] = {0};
int ret = read(fd, buf, sizeof(buf) - 1);
if(ret < 0)
{
perror("read error");
return -1;
}
else if(ret == 0)
{
printf("all write is closed\n");
return -1;
}
printf("read buf is:%s\n", buf);
}
close(fd);
return 0;
}
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <sys/stat.h>
int main()
{
// int mkfifo(const char *pathname, mode_t mode);
// pathname:管道文件名称
// mode:管道文件权限
// 返回值：0 失败：-1
const char* fifo = "./test.fifo";
umask(0);
int ret = mkfifo(fifo, 0664);
if (ret < 0 && errno != EEXIST)
{
perror("mkfifo error");
return -1;
}
int fd = open(fifo, O_WRONLY);
if (fd < 0)
{
perror("open fifo error");
return -1;
}
printf("open fifo success\n");
int i = 0;
while (1)
{
char buf[1024] = {0};
sprintf(buf, "hello world---%d", i++);
write(fd, buf, strlen(buf));
sleep(1);
}
close(fd);
return 0;
}
管道总结
匿名管道只能用于具有亲缘关系的进程间通信；命名管道可以用于同一主机上的任意进程间通信
管道是半双工通信，可选方向的单向通信
匿名管道的读写特性，命名管道的读写特性和打开特性
管道的生命周期随进程
管道提供流式服务，字节流传输（传输灵活/数据粘连）
管道自带同步与互斥功能（管道的读写数据大小在不超过PIPE_BUF时保证操作的原子性）
- 互斥：对临界资源的同一时间的唯一访问性（我操作的时候别人不能操作）
- 同步：对临界资源访问的时序可控性（我操作完了别人才能操作）
共享内存
共享内存：最快的进程间通信方式
原理：
- 在物理内存中开辟一块内存空间
- 将这块内存空间通过页表映射到进程的虚拟地址空间中
- 进程可以直接通过进程虚拟地址访问到这块物理内存进行操作（若多个进程映射到同一块物理内存，就可以实现相互通信；直接通过虚拟地址改变内存中的数据，其它进程也会随之改变；相较于其它进程通信方式，少了两步内核态与用户态之间的数据拷贝过程），因此速度最快。
- 共享内存并没有自带同步与互斥，多个进程进行访问时存在安全问题
操作步骤：
- 创建共享内存
int shmget(key_t key, size_t size, int shmflg); - 将共享内存映射到虚拟地址空间
void *shmat(int shmid, const void *shmaddr, int shmflg); - 直接对这块内存进行操作
memcpy/strcpy - 解除映射关系
int shmdt(const void *shmaddr); - 删除共享内存
int shmctl(int shmid, int cmd, struct shmid_ds *buf);
1.创建共享内存
- key：共享内存标识符
- size：共享内存大小
- shmflg：选项标志
IPC_CREAT：共享内存不存在则创建，存在则打开
IPC_EXCL：与IPC_CREAT同用，则共享内存存在时报错
shm_mode：权限 - 返回值：成功：返回标识符（共享内存的操作句柄） 失败：-1
2.建立映射关系
- shmid：创建共享内存，返回的操作句柄
- shmaddr：共享内存映射在虚拟地址空间中的首地址，通常置空
- shmflg：映射成功后的操作权限
SHM_RDONLY：只读
0：默认-可读可写 - 返回值：成功：返回映射首地址 失败：(void*) -1
3.对共享内存的操作：根据用户需求来选择
4.解除映射关系
- shmaddr：映射首地址
5.删除共享内存
- shmid：共享内存操作句柄
- cmd：即将进行的操作
IPC_RMID：删除共享内存 - buf：设置/获取共享内存信息
如：shmctl(shmid, IPC_RMID, NULL)
buf：如果不想获取，置空 - 共享内存不会被直接删除，而是判断映射连接数是否为0
为0：直接删除
不为0：拒绝后续其它进程的映射连接，当映射连接数为0时自动删除
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/shm.h>
#define IPC_KEY 0x12345678
int main()
{
// 创建共享内存
int shmid = shmget(IPC_KEY, 32, IPC_CREAT | 0664);
if(shmid < 0)
{
perror("shmget error");
return -1;
}
// 建立映射
void* shm_start = shmat(shmid, NULL, 0);
if(shm_start == (void*)-1)
{
perror("shmat error");
return -1;
}
// 共享内存的操作
while(1)
{
printf("%s\n", shm_start);
sleep(1);
}
// 解除映射关系
shmdt(shm_start);
// 删除共享内存
shmctl(shmid, IPC_RMID, NULL);
return 0;
}
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <sys/shm.h>
#define IPC_KEY 0x12345678
int main()
{
// 创建共享内存
int shmid = shmget(IPC_KEY, 32, IPC_CREAT | 0664);
if(shmid < 0)
{
perror("shmget error");
return -1;
}
// 建立映射
void* shm_start = shmat(shmid, NULL, 0);
if(shm_start == (void*)-1)
{
perror("shmat error");
return -1;
}
// 共享内存的操作
int i = 0;
while(1)
{
sprintf((char*)shm_start, "今天天气很好--%d", i++);
sleep(1);
}
// 解除映射关系
shmdt(shm_start);
// 删除共享内存
shmctl(shmid, IPC_RMID, NULL);
return 0;
}
消息队列
消息队列：不常用
操作系统在内核中为用户创建的一个队列；其它进程可以通过访问相同的队列进行通信。
消息队列传输的是有类型的数据块。
信号量
信号量：用于实现进程间同步与互斥
- 本质：内核中的一个计数器，带有pcb等待队列
- 计数器：数据资源的计数器，用于判断是否能够进行操作
- 获取数据时，先判断计数器是否>0
若计数>0：表示有资源，才可以获取数据，并且计数-1
若计数<=0：表示没有资源，则阻塞等待 - 产生数据时，进行计数+1，并且唤醒等待的进程
信号量用于实现进程/线程间的同步与互斥
- 同步：保证进程间对临界资源访问的时序合理性
- 互斥：保证进程间对临界资源访问的安全性
同步保证时序合理：让进程在能够访问临界资源的情况下，才放行；否则需要让进程进行等待，等到其它进程促使资源访问资源条件满足后，唤醒等待的进程，去进行访问临界资源。
互斥保证访问安全：同一时间只允许一个进程访问临界资源，避免数据操作的二义性，使用两种状态来标记，临界资源当前是否允许访问，一个进程访问之前应该询问状态，并且访问期间需要将状态标记为不允许访问状态，避免其它进程争抢。
信号量实现同步：等待+唤醒
信号量实现互斥：计数器只有0/1+等待+唤醒
进程间通信方式的查看：ipcs [-m -s -q]
m：查看共享内存 s：查看信号量 q：查看消息队列
进程间通信方式的删除：ipcrm [-m -s -q] shmid(操作句柄)
扫一扫
1105
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
