目录
在Linux下的多个进程间的通信机制叫做IPC,它是多个进程之间相互沟通的一种方法。在Linux下有多种进程间通信的方法:半双工管道、FIFO (命名管道)、消息队列、信号量、共享内存等。使用这些通信机制可以为Linux下的网络服务器开发提供灵活而又坚固的框架。
匿名管道
管道是种把两个进程之间的标准输入和标准输出连接起来的机制。管道是一种历史悠久的进程间通信的办法，自UNIX操作系统诞生，管道就存在了。
1.基本概念
由于管道仅仅是将某个进程的输出和另一个进程的输入相连接的单向通信的办法，因此称其为“半双工”。在shell中管道用“ | ”表示。
把ls -l的输出当做“grep *.c”的输入，管道在前一个进程中建立输入通道，在后一个进程建立输出通道，将数据从管道的左边传输到管道的右边将ls -l的输出通过管道传给“grep *.c”。
进程创建管道，每次创建两个文件描述符来操作管道。其中一个对管道进行写操作，另一个描述符对管道进行读操作。管道将两个进程通过内核连接起来，两个文件描述符连接在一起。如果进程通过管道fda[0]发送数据，它可以从fdb[0]获得信息。
由于进程A和进程B都能够访问管道的两个描述符，因此管道创建完毕后要设置在各个进程中的方向，希望数据向那个方向传输。这需要做好规划，两个进程都要做统一的设置，在进程A中设置为读的管道描述符，在进程B中要设置为写；反之亦然，并且要把不关心的管道端关掉。对管道的读写与一般的I0系统函数一致， 使用write()函数写入数据，read()函数读出数据，某些特定的IO操作管道是不支持的，例如偏移函数lseek()。
创建管道---pipe()
fd是一个文件描述符的数组，用于保存管道返回的两个文件描述符。数组中的第1个元素(下标为0)是为了读操作而打开的，而第2个元素(下标为1)，是为了写操作而创建和打开的。(0看作一张嘴，用来读，1看作一支笔，用来写)。当函数执行成功时返回0，失败返回错误代码。
只建立管道看起来没有什么用处，要使管道有切实的用处，需要与进程的创建结合起来，利用两个管道在父进程和子进程之间进行通信。在父进程和子进程之间建立一个管道， 子进程向管道中写入数据，父进程从管道中读取数据。要实现这样的模型，在父进程中需要关闭写端，在子进程中需要关闭读端。
#include <iostream>
#include <unistd.h>
#include <string>
#include <string.h>
#include <cerrno>
#include <cassert>
#include <sys/types.h>
using namespace std;
int main()
{
// 任何一种任何一种进程间通信中，一定要先保证不同的进程之间看到同一份资源
int pipefd[2] = {0};
//1. 创建管道
int n = pipe(pipefd);
if(n < 0)
{
std::cout << "pipe error, " << errno << ": " << strerror(errno) << std::endl;
return 1;
}
//2.创建子进程
pid_t id=fork();
assert(id != -1);
if(id==0)
{
//子进程
//3.关闭不需要的fd，让父进程进行读取，子进程进行写入
close(pipefd[0]);
//4.开始通信
string strmessage="hello,我是子进程";
char buffer[1024];
int count=1;
while(true)
{
snprintf(buffer,sizeof buffer,"%s,计数器：%d,我的PId:%d",strmessage.c_str(),count++,getpid());
write(pipefd[1],buffer,strlen(buffer));
sleep(1);
}
close(pipefd[1]);
exit(0);
}
//父进程
//3.关闭不需要的fd，让父进程进行读取，子进程进行写入
close(pipefd[1]);
//4.开始通信
char buffer[1024];
while(true)
{
int n=read(pipefd[0],buffer,sizeof(buffer)-1);
if(n>0)
{
buffer[n]='\0';
cout<<"我是父进程，child give me message:"<<buffer<<endl;
}
}
close(pipefd[0]);
return 0;
}
#include <iostream>
#include <string>
#include <cerrno>
#include <cassert>
#include <string.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
int main()
{
int pipefd[2] = {0};
//1. 创建管道
int n = pipe(pipefd);
if(n < 0)
{
std::cout << "pipe error, " << errno << ": " << strerror(errno) << std::endl;
return 1;
}
std::cout << "pipefd[0]: " << pipefd[0] << std::endl; // 读端， 0->嘴巴->读书
std::cout << "pipefd[1]: " << pipefd[1] << std::endl; // 写端， 1->笔->写东西的
//2. 创建子进程
pid_t id = fork();
assert(id != -1);
if(id == 0)// 子进程
{
//3. 关闭不需要的fd，让父进程进行读取，让子进程进行写入
close(pipefd[0]);
//4. 开始通信 -- 结合某种场景
// const std::string namestr = "hello， 我是子进程";
// int cnt = 1;
// char buffer[1024];
int cnt = 0;
while(true)
{
char x = 'X';
write(pipefd[1], &x, 1);
std::cout << "Cnt: " << cnt++<<std::endl;
sleep(1);
// break;
// snprintf(buffer, sizeof buffer, "%s, 计数器: %d, 我的PID: %d", namestr.c_str(), cnt++, getpid());
// write(pipefd[1], buffer, strlen(buffer));
}
close(pipefd[1]);
exit(0);
}
//父进程
//3. 关闭不需要的fd，让父进程进行读取，让子进程进行写入
close(pipefd[1]);
//4. 开始通信 -- 结合某种场景
char buffer[1024];
int cnt = 0;
while(true)
{
// sleep(10);
// sleep(1);
int n = read(pipefd[0], buffer, sizeof(buffer) - 1);
if(n > 0)
{
buffer[n] = '\0';
std::cout << "我是父进程, child give me message: " << buffer << std::endl;
}
else if(n == 0)
{
std::cout << "我是父进程, 读到了文件结尾" << std::endl;
break;
}
else
{
std::cout << "我是父进程, 读异常了" << std::endl;
break;
}
sleep(1);
if(cnt++ > 5) break;
}
close(pipefd[0]);
int status = 0;
waitpid(id, &status, 0);
std::cout << "sig: " << (status & 0x7F) << std::endl;
sleep(100);
return 0;
} 
命名管道
命名管道的工作方式与普通的管道非常相似，但也有一些明显的区别。
创建FIFO
有许多种方法可以创建命名管道。其中，可以直接用shell来完成。例如，在当前目录下建立一一个名字为namedfifo的命名管道:
可以看出namedfifo的属性中有一个p,表示这是个管道。
命名管道也可以从程序里创建，相关函数有：
创建命名管道：
FIFO 操作
对命名管道FIFO来说，IO操作与普通的管道IO操作基本上是一样的，二者之间存在着一个主要的区别。在FIFO中，必须使用一个open()函数来显式地建立连接到管道的通道。一般来说FIFO总是处于阻塞状态。也就是说，如果命名管道FIFO打开时设置了读权限，则读进程将一直“阻塞”，一直到其他进程打开该FIFO并且向管道中写入数据。这个阻塞动作反过来也是成立的，如果一个进程打开一个管道写入数据，当没有进程冲管道中读取数据的时候，写管道的操作也是阻塞的，直到已经写入的数据被读出后，才能进行写入操作。如果不希望在进行命名管道操作的时候发生阻塞，可以在open()调用中使用O_NONBLOCK标志，以关闭默认的阻塞动作。
用命名管道实现server&client通信
comm.hpp(client.cc和server.cc的命名管道)
#pragma once
#include <iostream>
#include <string>
#define NUM 1024
const std::string fifoname="./fifo";
uint32_t mode = 0666;server.cc
#include <iostream>
#include <cerrno>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include "comm.hpp"
int main()
{
// 1. 创建管道文件，只需要一次创建
umask(0); //这个设置并不影响系统的默认配置，只会影响当前进程
int n = mkfifo(fifoname.c_str(), mode);
if(n != 0)
{
std::cout << errno << " : " << strerror(errno) << std::endl;
return 1;
}
std::cout << "create fifo file success" << std::endl;
// 2. 让服务端直接开启管道文件
int rfd = open(fifoname.c_str(), O_RDONLY);//只读方式打开
if(rfd < 0 )
{
std::cout << errno << " : " << strerror(errno) << std::endl;
return 2;
}
std::cout << "open fifo success, begin ipc" << std::endl;
// 3. 正常通信
char buffer[NUM];
while(true)
{
buffer[0] = 0;
ssize_t n = read(rfd, buffer, sizeof(buffer) - 1);
if(n > 0)
{
buffer[n] = 0;
std::cout << "client# " << buffer << std::endl;
//printf("%c", buffer[0]);
//fflush(stdout);
}
else if(n == 0)
{
std::cout << "client quit, me too" << std::endl;
break;
}
else
{
std::cout << errno << " : " << strerror(errno) << std::endl;
break;
}
}
// 关闭不要的fd
close(rfd);
unlink(fifoname.c_str());
return 0;
}client.cc
#include <iostream>
#include <cstdio>
#include <cerrno>
#include <cstring>
#include <cassert>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
// #include <ncurses.h>
#include "comm.hpp"
int main()
{
//1. 不需创建管道文件，我只需要打开对应的文件即可！
int wfd = open(fifoname.c_str(), O_WRONLY);//只写方式打开
if(wfd < 0)
{
std::cerr << errno << ":" << strerror(errno) << std::endl;
return 1;
}
// 可以进行常规通信了
char buffer[NUM];
while(true)
{
std::cout<<"请输入你的消息#：";
char *msg = fgets(buffer,sizeof(buffer),stdin);
assert(msg);
(void)msg;
buffer[strlen(buffer)-1]=0;
if(strcasecmp(buffer,"quit") == 0) break;
ssize_t n = write(wfd,buffer,strlen(buffer));
assert(n > 0);
(void)n;
}
close(wfd);
return 0;
}
共享内存
共享内存是在多个进程之间共享内存区域的一种进程间的通信方式，它是在多个进程之间对内存段进行映射的方式实现内存共享的。这是IPC最快捷的方式，因为共享内存方式的通信没有中间过程，而管道、消息队列等方式则是需要将数据通过中间机制进行转换；与此相反，共享内存方式直接将某段内存段进行映射，多个进程间的共享内存是同一块的物理空间，仅仅是地址不同而已，因此不需要进行复制，可以直接使用此段空间。
1.创建共享内存函数shmget()
函数shmget()用于创建一个新的共享内存段， 或者访问一个现有的共享内存段。函数shmget()的原型如下:
shmget()的第一个参数是关键字的值。然后，这个值将与内核中现有的其他共享内存段的关键字值相比较。在比较之后，打开和访问操作都将依赖于shmflg参数的内容。
- IPC_CREAT:如果在内核中不存在该内存段，则创建它。
- IPC_EXCL:当与IPC CREAT 一起使用时，如果该内存段早已存在，则此次调用将失败。
如果只使用IPC_CREAT, shmget()或者 将返回新创建的内存段的段标识符，或者返回早已存在于内核中的具有相同关键字值的内存段的标识符。如果同时使用IPC_CREAT和IPC_EXCL,则可能会有两种结果:如果该内存段不存在，则将创建一个新的内存段;如果内存段早已存在，则此次调用失败，并将返回-1。IPC_EXCL本身是没有什么用处的，但在与IPC_CREAT组合使用时，它可用于防止一个现有的内存段为了访问而打开着。一旦进程获得了给定内存段的合法IPC标识符，它的下一步操作就是连接该内存段，或者把该内存段映射到自己的寻址空间中。
2.获得共享内存地址函数shmat()
函数shmat()用来获取共享内存的地址，获取共享内存成功后，可以像使用通用内存一样对其进行读写操作。函数的原型如下:
如果shmaddr参数值等于0，则内核将试着查找一个未映射的区域。用户可以指定个地址，但通常该地址只用于访问所拥有的硬件，或者解决与其他应用程序的冲突。SHM_RND标志可以与标志参数进行OR操作，结果再置为标志参数，这样可以让传送的地址页对齐。
此外，如果把SHM_RDONLY标志与标志参数进行OR操作，结果再置为标志参数，这样映射的共享内存段只能标记为只读方式。
当申请成功时，对共享内存的操作与一般内存一样，可以直接进行写入和读出，以及偏移的操作。
3.删除共享内存函数shmdt()
函数shmdt()用于删除一段共享内存。 函数的原型如下:
当某进程不再需要一个共享内存段时，它必须调用这个函数来断开与该内存段的连接。这与从内核删除内存段是两回事。在成功完成了断开连接操作以后，相关的shmid ds结构的shm nattch成员的值将减去1。如果这个值减到0，则内核将真正删除该内存段。
4.共享内存控制函数shmctl()
共享内存的控制函数shmctl的使用类似iocl()的方式对共享内存进行操作:向共享内存的句柄发送命令来完成某种功能。函数shmcl()的原型如下，其中shmid是其享内存的句柄，emd是向共享内存发送的命令，最后一个参数 buf则是向共享内存发送命令的参数。
- IPC_STAT:把shmid_ds结构中的数据设置为共享内存的当前关联值。
- IPC_SET:获取内存段的shmid_ds结构，并把它存储在buf参数所指定的地址中。IPC_ SET设置内存段shmid_ds 结构的ipc_perm 成员的值，此命令是从buf参数中获得该值的。
- IPC_ RMID:标记某内存段，以备删除。该命令并不真正地把内存段从内存中删除。相反，它只是标记上该内存段，以备将来删除。只有当前连接到该内存段的最后一个进程正确地断开了与它的连接，实际的删除操作才会发生。当然，如果当前没有进程与该内存段相连接，则删除将立刻发生。为了正确地断开与其共享内存段的连接，进程需要调用shmdt()函数。
小实验：
comm.hpp(对方法的封装)
#ifndef __COMM_HPP__
#define __COMM_HPP__
#include <iostream>
#include <cerrno>
#include <cstdio>
#include <cstring>
#include <cassert>
#include <string>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/types.h>
#include <sys/stat.h>
using namespace std;
// IPC_CREAT and IPC_EXCT
// 单独使用 IPC_CREAT :创建一个共享内存，如果共享内存不存在 ，就创建它；如果存在，就获取已经存在的共享内存并且返回
// IPC_EXCT不能单独使用，一般都要配合IPC_CREAT
// IPC_CREAT |IPC_EXCT:创建一个共享内存，如果共享内存不存在，就创建它，如果存在，出错并返回（如果共享内存创建成功，则这个共享内存一定是最新的）
#define PATHNAME "."
#define PROJID 0x6666
const int gsize = 4096;
key_t getKey()
{
key_t k = ftok(PATHNAME, PROJID);
if (k == -1)
{
cerr << "error:" << errno << strerror(errno) << endl;
exit(1);
}
return k;
}
// 十六进制转换
string toHex(int x)
{
char buffer[64];
snprintf(buffer, sizeof buffer, "0x%x", x);
return buffer;
}
static int createShmHelper(key_t k, int size, int flag)
{
int shmid = shmget(k, size, flag);
if (shmid == -1)
{
cerr << "error:" << errno << ":" << strerror(errno) << endl;
exit(2);
}
return shmid;
}
int createShm(key_t k, int size)
{
umask(0);
return createShmHelper(k, size, IPC_CREAT | IPC_EXCL | 0666);
}
int getShm(key_t k, int size)
{
umask(0);
return createShmHelper(k, size, IPC_CREAT);
}
char *attachShm(int shmid)
{
char *start = (char *)shmat(shmid, nullptr, 0);
return start;
}
void detachShm(char *start)
{
int n = shmdt(start);
assert(n != -1);
(void)n;
}
void delShm(int shmid)
{
int n = shmctl(shmid, IPC_RMID, nullptr);
assert(n != -1);
(void)n;
}
#define SERVER 1
#define CLIENT 0
class Init
{
public:
Init(int t)
:type(t)
{
key_t k = getKey();
if(type == SERVER)
shmid = createShm(k,gsize);
else
shmid = getShm(k,gsize);
start = attachShm(shmid);
}
char* getStart(){return start;}
~Init()
{
detachShm(start);
if(type == SERVER)
delShm(shmid);
}
private:
char*start;
int type;//server or client
int shmid;
};
#endifserver.cc
#include "comm.hpp"
#include <unistd.h>
int main()
{
Init init(SERVER);
char* start = init.getStart();
int n = 0;
while(n <= 26)
{
cout<<"client -> server#"<<start<<endl;
sleep(1);
n++;
}
// //1.创建key
// key_t k = getKey();
// cout<<"server key:"<<toHex(k)<<endl;
// //2.创建共享内存
// int shmid = createShm(k,gsize);
// cout<<"server shmid:"<<shmid<<endl;
// //3.将自己和共享内存关联起来
// char* start = attachShm(shmid);
// sleep(5);
// //4.将自己和共享内存去关联
// detachShm(start);
// //删除共享内存
// delShm(shmid);
return 0;
}
client.cc
#include "comm.hpp"
#include <unistd.h>
#include <string>
#include <vector>
int main()
{
Init init(CLIENT);
char* start = init.getStart();
char c = 'A';
while(c <= 'Z')
{
start[c - 'A'] = c;
c++;
start[c - 'A'] = '\0';
sleep(1);
}
// //1.创建key
// key_t k = getKey();
// cout<<"client key:"<<toHex(k)<<endl;
// //2.创建共享内存
// int shmid = createShm(k,gsize);
// cout<<"client shmid:"<<shmid<<endl;
// //3.将自己和共享内存关联起来
// char* start = attachShm(shmid);
// sleep(10);
// //4.将自己和共享内存去关联
// detachShm(start);
return 0;
}
