目录
1. 介绍
1.1 进程间通信的目的
- 数据传输：一个进程需要将它的数据发送给另一个进程
- 资源共享：多个进程之间共享同样的资源。
- 通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件 （如进程终止 时要通知父进程）。
- 进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望 能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变
- 有时候也需要多进程协同进行工作
如何理解进程间通信的本质问题呢？
- OS需要直接/间接的给通信双方的进程提供"内存空间"
- 要通信的不同进程必须看到同一份公共资源
1.2 进程间通信的分类
- 管道
- SystemV(本文只讨论共享内存) -- 让通信过程可以跨主机
- POSIX -- 聚焦在本地通信
2. 管道
2.1 什么是管道
-
管道是 Unix 中最古老的进程间通信的形式
-
我们把从一个进程连接到另一个进程的一个数据流称为一个 “ 管道 ”
管道又分匿名管道和命名管道两种。
2.2 匿名管道
2.2.1 接口
#include <ustdio.h>
int pipe(int pipefd[2]);
参数：piepfd[]为输出型参数，pipefd[0]为读文件描述符，pipefd[1]为写文件描述符，若为其他的文件描述符使用，一般这两个fd分别为3、4。返回值：创建成功返回0，失败返回-1
2.2.2 步骤--以父子进程通信为例
- 父进程利用pipe接口创建管道，分别以读和写打开一个文件
- 父进程fork出子进程
- 父进程关闭fd[1]，子进程关闭fd[0]
- 这样父进程就可以往管道文件中写数据，子进程从管道文件中读数据，实现了父子进程的通信
注：管道一般是单向的，其实管道也是一个文件("内核级文件")--不需要进行磁盘IO(当然也可以用磁盘文件来实现这个管道操作，但是要进行磁盘读取，太慢了)
若是管道中没有数据了，但是读端还在读，OS会直接阻塞当前正在读取的进程。
2.2.3 站在文件描述符角度-深度理解
2.2.4 管道代码
在这个代码部分，可以实验当读快写慢、读慢写快、只读关闭、只写关闭四种情况，这里只给出了只有读关闭的情况
#include <iostream>
#include <cstdio>
#include <unistd.h>
#include <cassert>
#include <sys/stat.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <cstring>
using namespace std;
int main()
{
// 第一步：创建管道文件
int fds[2];
int n = pipe(fds);
assert(n == 0);
// 0 1 2应该是被占用的 _-> 3 4
cout << "fds[0]: " << fds[0] << endl;
cout << "fds[1]: " << fds[1] << endl;
// 第二步：fork
pid_t id = fork();
assert(id >= 0);
if(id == 0)
{
// 子进程的通信代码 子进程写入
close(fds[0]);
// 通信代码
// string msg = "hello, i am child!";
int cnt = 0;
const char* s = "我是子进程，我正在给你发消息！";
while(1)
{
cnt++;
char buffer[1024]; // 只有子进程能看到
snprintf(buffer, sizeof buffer, "child->parent say: %s[%d][%d]", s, cnt,
getpid());
// 往文件中写入数据
write(fds[1], buffer, strlen(buffer));
// sleep(50); // 细节 每隔一秒写一次
// break;
}
cout << "子进程关闭写端" << endl;
close(fds[1]);
exit(0);
}
// 父进程的通信代码 父进程读取
close(fds[1]);
while(1)
{
char buffer[1024];
// cout << "AAAAAAAAAAAAAAA" <<endl;
// 父进程在这里阻塞等待
ssize_t s = read(fds[0], buffer, sizeof(buffer) - 1);
// cout << "BBBBBBBBBBBBBBB" <<endl;
if(s > 0)
{
buffer[s] = 0;
cout << " Get Message# " << buffer <<" | my pid: " << getpid() << endl;
}
else if(s == 0)
{
cout << "read: " << s << endl;
break;
}
// cout << "Get Message#" << buffer << " | my pid: " << getppid() << endl;
// 细节：父进程可没有进行sleep
//sleep(5);
// close(fds[0]);
break;
}
close(fds[0]);
int status = 0;
cout << "父进程关闭读端" << endl;
n = waitpid(id, &status, 0);
assert(n == id);
cout << "pid->" << n << ":" << (status & 0x7F) << endl; // 信号为13：SIGPIPE 中止了写入进程
return 0;
}
由上面代码结果可以看出，当读关闭时，OS会终止写端，给写进程发送信号，终止写端。写进程收到13号信号
2.2.5 读写特征
- 读快，写慢 -- 读进程会阻塞，等到管道中有数据时继续读取，子进程没有写入的那段时间， 若管道中没有数据时，父进程会在read处阻塞等待
- 读慢，写快 -- 写进程正常写数据，管道写满时，会在write处阻塞，读进程就绪时，继续读取 数据
- 写关闭 -- 管道中的数据会被读取完毕后返回EOF，此时
read函数会返回0,最后等待子进程关 闭读端 - 读关闭 -- OS会中止写端，给写端发送信号--13 SIGPIPE，终止写端
2.2.6 管道特征
- 管道的生命周期随进程
- 管道可以用来进行具有血缘关系的进程通信，常用于父子进程
- 管道是面向字节流的
- 单向通信 -- 半双工通信
- 互斥与同步机制 -- 对共享资源进行保护额方案
2.3 命名管道
- 管道应用的一个限制就是只能在具有共同祖先（具有亲缘关系）的进程间通信。
- 如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作，它经常被称为命名管道。
- 命名管道是一种特殊类型的文件
- 在用命名管道实现两个进程通信时，任意一个进程调用mkfifo创建命名管道即可
2.3.1 接口
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char* pathname, mode_t mode);
参数：pathname：命名管道的路径名 mode：管道权限
返回值：成功返回0；失败返回-1，并设置errno来指示错误原因
int unlink(const char* pathname); --在进程结束后，清理和删除命名管道。
参数：命名管道的路径名
返回值：成功返回0；失败返回-1，并设置errno来指示错误原因
命名管道可以从命令行上创建，命令行方法是使用下面这个命令：
mkfifo filename # filename为命名管道文件名
2.3.2 代码实现
#include <iostream>
#include "comm.hpp"
using namespace std;
int main()
{
bool r = createFifo(NAMED_PIPE);
assert(r);
(void)r;
cout << "server begin" << endl;
int rfd =open(NAMED_PIPE, O_RDONLY); // 只读方式打开
cout << "server end" << endl;
if(rfd < 0)
{
cout << "文件打开失败！" << endl;
exit(1);
}
// read
char buffer[1024];
while(true)
{
ssize_t s = read(rfd, buffer, sizeof buffer - 1);
if(s > 0)
{
buffer[s] = 0;
std::cout << "client->server:" << buffer << endl;
}
else if(s == 0)
{
cout << "client quit, me too!" << endl;
break;
}
else{
cout << "err string:" << strerror(errno) << endl;
break;
}
}
close(rfd);
// sleep(10);
removeFifo(NAMED_PIPE);
return 0;
}
client.cc
#include <iostream>
#include "comm.hpp"
using namespace std;
int main()
{
// 与server打开同一个文件
cout << "client begin" << endl;
int wfd = open(NAMED_PIPE, O_WRONLY);
cout << "client end" << endl;
if(wfd < 0)
{
cout << "文件打开失败！" << endl;
exit(1);
}
// write
char buffer[1024];
while(true)
{
cout << "Please Say# ";
fgets(buffer, sizeof(buffer)-1, stdin);
if(strlen(buffer) > 0) buffer[strlen(buffer)-1] = 0;
ssize_t s = write(wfd, buffer, strlen(buffer));
assert(s == strlen(buffer));
(void)s;
}
close(wfd);
return 0;
} comm.hpp
#pragma once
#include <string>
#include <iostream>
#include <sys/types.h>
#include <sys/stat.h>
#include <cstring>
#include <cassert>
#include <cerrno>
#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>
#define NAMED_PIPE "/tmp/mypipe.106"
bool createFifo(const std::string& path)
{
umask(0);
int n = mkfifo(path.c_str(), 0600); // 只允许拥有者通信
if(n == 0) return true;
else{
std::cout << "erro" << errno << "err string: " << strerror(errno) << std::endl;
return false;
}
}
void removeFifo(const std::string & path)
{
int n = unlink(path.c_str());
assert(n == 0); // debug有效，release里面就无效
(void)n; // 不想有警告
} 可以看到client可以向server端发送数据，server收到并打印到屏幕中，实验结果如下图所示：
下图为命名管道的信息：
2.3.3 匿名管道和命名管道的区别
-
匿名管道由pipe函数创建并打开。
-
命名管道由mkfifo函数创建，打开用open
-
FIFO（命名管道）与pipe（匿名管道）之间唯一的区别在它们创建与打开的方式不同，一但这些工作完成之后，它们具有相同的语义。
3. system V共享内存
3.1 共享内存的原理
原理：是不同的进程通过各自的PCB和页表访问同一快共享内存
3.2 步骤
- 申请一块空间
- 将创建好的内存映射(将进程和共享内存挂接)到不同的进程地址空间
- 若未来不想通信：取消进程和内存的映射关系--去关联、释放共享内存
3.3 系统接口
#include <sys/ipc.h>
#include <sys.shm.h>
int shmget(key_t key, size_t size, int shmflg);
参数：key: 进行唯一性标识 -- 将key使用shmget设置进入共享内存属性中，用来表示共享 内存在内核中的唯一性
size：申请空间大小--一般为4KB的整数倍
shmflg：IPC_CREAT--如果指定的共享内存不存在，创建；如果存在，获取共享内存
IPC_EXCL--无法单独使用 使用：IPC_CREAT|IPC_EXCL：如果不存在， 创建--创建的一定是一个新的共享内存；存在则出错返回，还可以通过其 设置共享内存的权限
返回值：成功返回标识符shmid；失败，返回-1，与文件不同
key_t ftok(char* pathname, char proj_id); -- 使用给定路径名命名的文件的标识(必须引用一个现有的，可访问的文件)和proj_id的最低有效8位(必须是非零的)来生成key_t类型的System V IPC密钥返回值：成功返回key_t值，失败返回-1
解析：
创建共享内存时，如何保证其在系统中是唯一的？-- 通过参数key确定的，只要保证另一个要通信的进程看到相同的key值，通过在各个共享内存的属性中查找相同的key，即可找到同一块共享内存--通过相同的pathname和proj_id在不同的进程中调用ftok获得相同的key。那么key在哪里呢？ -- 在结构体struct stm中。
IPC资源的特征：共享内存的生命周期是随OS的，不是随进程的，若没有对共享内存进行手动的删除，那么该资源不会消失
查看IPC资源的命令：ipcs -m(共性内存) /-q(消息队列)/-s(信号量)
删除IPC资源的执行：ipcrm -m shmid
操作共享内存
int shmctl(int shmid, int cmd, struct shmid_ds* buf);
参数：shmid：shmget的返回值--要控制哪一个共享内存
cmd：IPC_RMID -- 删除共享内存段 谁创建谁删除
IPC_STAT -- 获取共享内存属性
IPC_SET -- 设置共享内存属性
buf:
返回值：失败返回-1
关联进程
void* shmat(int shmid, const void* shmaddr, int shmflg);
参数：shmid：
shmaddr：将共享内存映射到哪一个地址空间中，一般设为nullptr 核心自动选择 一个地址
shmflg：一般设置为0，读写权限
返回值：共享内存空间的起始地址
去关联：并不是删除共享内存，而是去除PCB和共享内存的映射关系int shmdt(const void* shmaddr);
参数：shmaddr-由shmat所返回的指针
返回值：失败返回-1
3.4 代码
// common.hpp
#ifndef _COMM_HPP_
#define _COMM_HPP_
#include <iostream>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/shm.h>
#include <cerrno>
#include <cstring>
#include <cstdlib>
#include <unistd.h>
#define PATHNAME "."
#define PROJ_ID 0x66
#define MAX_SIZE 4096
key_t getKey()
{
key_t k = ftok(PATHNAME, PROJ_ID); // 可以获取同样的key！
if(k < 0)
{
// cin cout cerr -> stdin stdout stderr -> 0,1,2
std::cerr << errno << ":" << strerror(errno) << std::endl;
exit(1);
}
return k;
}
int getShmHelper(key_t k, int flags)
{
int shmId = shmget(k, MAX_SIZE, flags);
if(shmId < 0)
{
std::cerr << errno << ":" << strerror(errno) << std::endl;
exit(2);
}
return shmId;
}
// 给之后的进程获取共享内存
int getShm(key_t k)
{
return getShmHelper(k, IPC_CREAT/*可以设定为0*/);
}
// 给第一个进程使用 创建共享内存
int creatShm(key_t k)
{
return getShmHelper(k, IPC_EXCL | IPC_CREAT | 0600); // 0600为权限
}
void *attachShm(int shmId)
{
void *mem = shmat(shmId, nullptr, 0); // 64位系统 指针占8字节
if((long long)mem == -1L)
{
std::cerr << "shmat " << errno << ":" << strerror(errno) << std::endl;
exit(3);
}
return mem;
}
void detachShm(void *start)
{
if(shmdt(start) == -1)
{
std::cerr << errno << ":" << strerror(errno) << std::endl;
}
}
void delShm(int shmId)
{
if(shmctl(shmId, IPC_RMID, nullptr) == -1)
{
std::cerr << errno << ":" << strerror(errno) << std::endl;
}
}
#endif
//shm_client.cc//
#include "common.hpp"
using namespace std;
int main()
{
key_t k = getKey();
printf("0x%x\n", k);
int shmId = getShm(k);
printf("shmId:%d\n", shmId);
// 关联
char *start = (char*)attachShm(shmId);
printf("sttach success, address start: %p\n", start);
// 使用
const char* message = "hello server, 我是另一个进程，正在和你通信！";
pid_t id = getpid();
int cnt = 1;
// char buffer[1024];
while(true)
{
sleep(1);
// 直接将需要传递的信息写在共享内存字符串中 省去了很多拷贝的过程 提高了传输信息的效率
snprintf(start, MAX_SIZE, "%s[pid:%d][消息编号:%d]", message, id, cnt++);
// snprintf(buffer, sizeof(buffer), "%s[pid:%d][消息编号:%d]", message, id, cnt);
// memcpy(start, buffer, strlen(buffer)+1);
}
// 去关联
detachShm(start);
// done
return 0;
}
/shm_server.cc///
#include "common.hpp"
using namespace std;
int main()
{
key_t k = getKey();
printf("0x%x\n", k);
// 申请共享内存
int shmId = creatShm(k);
printf("shmId:%d\n", shmId);
sleep(3);
// 关联
// 将共享内存看为一个字符串
char *start = (char*)attachShm(shmId);
printf("sttach success, address start: %p\n", start);
// 使用
while(true)
{
printf("client say: %s\n", start);
sleep(1);
}
// 去关联
detachShm(start);
sleep(5);
// 删除共享内存
delShm(shmId);
return 0;
}
上面的代码我们看到的现象是：
通过共享内存的方式实现了进程间通信
3.5 共享内存的优缺点
优点：
- 共享内存是所有通信中最快的，大大减少数据的拷贝次数
缺点：
- 不会给我们进行同步和互斥，没有对数据进行任何保护
问题--同样的代码，管道和共享内存方式实现各需要多少次拷贝 ？
4.信号量
4.1 相关概念
信号量 -- 本质是一个计数器，通常用来表示公共资源中，资源数量的多少问题
公共资源 -- 被多个进程同时访问的资源，访问没有保护的公共资源时，可能会导致数据不一致 问题
为什么要让不同进程看到同一份资源？ -- 实现进程间的协同工作，但是进程是具有独立性的， 为了让进程看到同一份资源，提出了进程间通信的方法，但是又带来了新的问题--数据不一致问题
临界资源：将被保护起来的公共资源称为临界资源，但是大部分的资源是独立的，只有少量的属于临 界资源，资源就是内存、文件、网络等
临界区：进程访问临界资源的代码被称为临界区，与之对应的为非临界区
保护公共资源：互斥、同步
原子性：要么不做，要做就做完，只有两种状态
4.2 信号量 -- 对资源的一种预定
为什么要有信号量？
设sem=20； sem--；// P操作，访问公共资源；sem++；// V操作，释放公共资源 --PV操作
所有的进程在访问公共资源前都必须先申请sem信号量，前提是所有进程必须先看到同一个信号量，那么信号量本身就是公共资源--也要保证自己的安全--信号量++、--的操作是原子操作
如果一个信号量的初始值为1，二维信号量/互斥信号量
4.3 系统接口
头文件
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
申请信号量
int semget(key_t key, int nsems, int semflg);
参数： key：对申请的信号量进行唯一性标识
nsems：申请几个信号量，与信号量的值无关
semflg：与共享内存的flag相同含义
返回值：成功返回信号量标识符semid，失败返回-1
删除信号量
int semctl(int semid, int semnum, int cmd,...);
参数：semid：信号量id，semget返回的值
semnum：信号量集的下标
cmd：IPC_RMID、IPC_STAT、IPC_SET
返回值：失败返回-1
操作信号量
int semop(int semid, struct sembuf* sops, unsigned nsops);
参数：semid：信号量id
sops：
信号量的详细操作会在多线程部分讲解