目录
进程间通信的目的
-
数据传输：一个进程需要将数据发送给另一个进程
-
资源共享：又多个进程需要共享同一份资源
-
事件通知：一个进程需要向一个进程或者一组进程发送通知的事件，通知他们发生了某种事件：例如 当子进程退出的时候，需要通知父进程。
-
进程控制：一个进程想要控制一个进程的执行顺序，或者是执行的节奏：例如 当 debug 的时候，需要控制进程，又或者是一个进场阻塞或者是异常了，另一个进场需要及时的知道它的状态改变。
进程间通信的方法
进程间通信有多种方法：
管道
-
而管道又可以分为 匿名管道和命名管道
-
匿名管道只能用于由血缘关系的进程之间的。
-
而命名管道可以利用与任何进程之间。
System V
-
这种通信方式用于同一台主机进程进程间通信。
-
如果想要跨主机通信，那么就需要使用网络（socket）
-
这种通信方式里面又包含三种：
-
消息队列
-
共享内存
-
信号量
-
POSIX
-
这种通信方式也是用于单主机的通信。
-
但是它的通信方式比较多：
-
消息队列
-
共享内存
-
信号量
-
互斥量
-
条件变量
-
读写锁
-
管道
管道里面分为匿名和命名的。
匿名管道
-
匿名管道，是只能用于又血缘关系的进场之间。
-
匿名管道不是双全工的！
-
为什么呢？
-
这里就需要提一下匿名管道的实现原理了。
匿名管道的实现原理
-
匿名管道为什么只能用于有血缘关系的进场？
-
因为匿名管道的实现，是利用了父子进程的数据拷贝！
-
再拷贝之前，父进程可以打开一个文件，即以读方式打开，又以写方式打开。
-
那么再 fork 的时候，父进程的文件描述符是数据吗？是的！
-
既然是数据，那么需要拷贝给子进程吗？需要！
-
既然可拷贝给子进程，但是真正打开的文件却只有一份，而父进程以读的方式打开，也以写的方式打开，而子进程继承下去也是如此，但是管道是单向的（只能从一边到另一边）。
-
所以我们可以认为父进程写，子进程读，所以我们可以关闭掉双方进程不需要的文件描述符。
-
而父进程只需要写即可，所以我们可以关闭掉父进程的读，而我们也可以关闭掉子进程的写。
-
这样，我们就可以让父进程一直写，让子进程一直读，这样就可以完成父子间通信了。
但是实际上，匿名管道并不需要我们自己实现，库里面有一个函数 pipe
NAME
pipe, pipe2 - create pipe
SYNOPSIS
#include <unistd.h>
int pipe(int pipefd[2]);-
这个函数可以帮助打开一个文件，以读方式和写方式！
-
这个参数是一个返回形参数，返回的就是两个文件描述符。
-
而 0 号文件描述符就是用来读的，1 号文件描述符用来写的。
pipe 函数是系统调用，而如果是我们自己打开的文件的话，那么是需要将数据刷新到磁盘上去的，但是pipe 函数是系统帮我们在内存上帮我们创建一个，并不会持久化到磁盘上，而数据也不需要刷新到磁盘上，因为实际上系统也是有内核缓冲区的。
利用 pipe 函数实现父子进程通信
// 匿名管道
int main()
{
// 1. 父进程利用 pipe 函数打开文件
int pipefd[2] = {-1};
int t = pipe(pipefd);
if(t == -1)
{
// 匿名管道创建失败
perror("pipe");
exit(1);
}
// 匿名管道创建成功
// 2. 创建子进程
int id = fork();
if(id == 0)
{
// 子进程
// pipe 的输出型参数返回两个文件描述符，0号文件描述符是读，1号是写
// 子进程负责读，所以子进程关闭1号文件描述符
close(pipefd[1]);
// 3. 让子进程一直死循环的读
char buffer[64] = {0};
while(true)
{
int s = read(pipefd[0], buffer,sizeof(buffer) - 1);
if(s > 0)
{
// 读取成功
buffer[s] = '\0';
cout << buffer << endl;
}
else if(s == 0)
{
// 对方关闭文件描述符，子进程也关闭文件描述符
cout << "parent close fd !!!!" << endl;
close(pipefd[0]);
break;
}
else if(s == -1)
{
// 读取失败
cout << "读取失败！" << endl;
exit(2);
}
}
return 0;
}
else
{
// 父进程
//父进程负责写，父进程关闭0号文件描述符
close(pipefd[0]);
// 3. 让父进程一直死循环的写内容
int count = 0;
while(true)
{
string message("send message to child: count = ");
message += to_string(count++);
write(pipefd[1], message.c_str(), message.size());
sleep(1);
if(count == 10)
{
close(pipefd[1]);
break;
}
}
// 4. waitpid
waitpid(-1, nullptr, 0);
}
return 0;
}命名管道
说完了匿名管道，实际上还有一个命名管道。
而匿名管道之所以叫匿名管道，那么因为系统帮我们做创建的内存级的文件，而该管道也是只能通过父子间继承使用，但是命名管道需要我们自己创建一个管道，同时也不需要时有血缘关系的进程之间才能使用，而且命名管道时需要我们自己创建的，是由名字的，所以称之为命名管道。
指令创建
创建命名管道，首先是可以通过指令创建的：
mkfifo name_pipe-
mkfifo 后面加命名管道的名字，就可以使用指令创建一个命名管道，而该管道也是可以让两个进程之间通信的。
[lxy@hecs-348468 linux109]$ mkfifo name_pipe
[lxy@hecs-348468 linux109]$ ll
total 0
prw-rw-r-- 1 lxy lxy 0 Oct 23 15:19 name_pipe-
这里看到了，我们创建了一个 name_pipe 的文件
-
该文件的类型是 p
-
我们之前说过，类型是 p 的表示为管道文件
下面看一下两个进程之间通信，我们启动两个 bash ，然后使用 name_pipe 文件，让两个 bash 之间通信：
下面使用一个 shell 脚本向 name_pipe 里面写入 hello world 然后使用另一个 bash cat 查看该文件
[lxy@hecs-348468 linux109]$ while :; do echo "hello world"; sleep 1; done > name_pipe;
下面看一下使用另一个bash 查看该文件
[lxy@hecs-348468 linux109]$ cat name_pipe
hello world
hello world
hello world
hello world该文件每隔一秒就会输入一条 hello world
实际上，如果我们另一个 bash 不进行读取的话，那么第一个bash也不会进行写入，就会阻塞在那里
[lxy@hecs-348468 linux109]$ echo hello world > name_pipe 就像这样，这个bash就会阻塞在这里，只有当另一个 bash 进行读取才可以。
[lxy@hecs-348468 linux109]$ cat name_pipe
hello world删除命名管道
-
创建命名管道的指令我们已经知道了，那么删除实际上可以使用普通的 rm 删除
-
还可以使用 unlink 来删除该文件
[lxy@hecs-348468 linux109]$ unlink name_pipe
[lxy@hecs-348468 linux109]$ ll
total 0使用命名管道通信
下面我们使用代码来控制：
先看一下创建命名管道和删除命名管道的函数：
NAME
mkfifo - make a FIFO special file (a named pipe)
SYNOPSIS
#include <sys/types.h>
#include <sys/stat.h>
int mkfifo(const char *pathname, mode_t mode);-
该函数就是创建一个命名管道
-
第一个参数就是想要创建的命名管道文件的路径，这里建议绝对路径
-
第二个就是 MODE 表示创建好的命名管道的权限，这里可以使用八进制的方式传入
-
这个返回值，如果是大于等于0，表示创建成功
-
如果小于0表示创建失败
NAME
unlink - delete a name and possibly the file it refers to
SYNOPSIS
#include <unistd.h>
int unlink(const char *pathname);-
该函数就是删除命名管道的函数
-
该函数只需要传入命名管道文件的路径即可
-
删除的话，如果返回-1表示删除失败，返会01表示成功
下面我们开始写我们的代码：
-
首先，既然我们需要两个进程看到同一份资源（也就是命名管道），所以首先，我们让服务区创建命名管道
-
服务器创建好后，然后服务器和客户端都只需要打开该文件
-
服务器主要是为了读取，所以服务器以读方式打开
-
客户端以写的方式打开，然后客户端可以写入数据，让服务器将这些数据回显到显示器上即可
-
下面我们先定义一个 common.hpp 的文件为了包含 server.cc 和 client.cc 的共同的头文件，以及宏...
#include<iostream>
using namespace std;
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/wait.h>
#include<unistd.h>
#include<string>
#include"Log.hpp"
#define PATH_NAME "name_pipe"
#define MODE 0666-
这里里面就是一些共同需要的头文件和一些宏
-
PATH_NAME 表示的是命名管道的路径，这里直接在当前目录下
-
MODE 表示想要打开的命名管道的权限
-
编写一个日志文件
#include<iostream>
using namespace std;
#include<string>
#include<ctime>
#include<vector>
#define NOTICE 0
#define WARING 1
#define ERROR 2
#define DEBUG 3
const vector<string> lev{
{"notice"},
{"waring"},
{"error"},
{"debug"}
};
ostream& Log(const string& message, int level)
{
cout << " | " << time(nullptr) << " | " << lev[level] << " | " << message << " | ";
return cout;
}-
这个日志文件，主要是为了服务器打印日志
-
这个日志文件会打印时间
-
还可以传入级别，这里的级别有 notice waring error debug
-
每次都会显示日志到显示器上。
-
编写服务器程序
#include"Common.hpp"
#include<fcntl.h>
#define SIZE 128 // 表示 buffer 也就是读取缓冲区的大小
#define NUM 3 // 表示创建子进程的数量
// 1. 主进程主要是为了创建命名管道文件
// 2. 创建好后，打开命名管道文件，然后创建 NUM 个子进程
// 3. 主要的任务交给子进程完成，也就是读取客户端发送的数据
// 4. 当创建好子进程后，父进程关闭掉打开的文件描述
// 5. 父进程等待创建的子进程
// 6. 父进程删除掉创建的命名管道
// 子进程执行的任务
void proTask(int fd)
{
// 3. 通信
char buffer[SIZE] = {0};
while(true)
{
int s = read(fd, buffer, SIZE - 1);
if(s > 0)
{
// 读取成功
buffer[s] = '\0';
cout << "进程 id: " << getpid() << " process >" << "client say# " << buffer << endl;
}
else if(s == 0)
{
// 对端关闭链接
Log("对方关闭链接，Server 也关闭链接~~~", DEBUG) << endl;
close(fd);
break;
}
else
{
//读取出错
Log("读取字符串出错了", ERROR) << endl;
exit(4);
}
}
}
int main()
{
//1. 创建一个命名管道
int fifo = mkfifo(PATH_NAME, MODE);
if(fifo < 0)
{
// 创建失败
perror("mkfifo");
exit(1);
}
Log("create 命名管道 success~", DEBUG) << "fifo: " << fifo << endl;
// 2. 打开该管道文件
int fd = open(PATH_NAME, O_RDONLY);
if(fd < 0)
{
perror("open");
exit(3);
}
Log("open 命名管道 success~", DEBUG) << "server 以读方式打开" << "fd: " << fd << endl;
for(int i = 0; i < NUM; ++i)
{
int id = fork();
if(id == 0)
{
Log("创建子进程 success~", DEBUG) << "id" << getpid() << endl;
// 子进程读取数据
proTask(fd);
exit(0);
}
}
// 父进程关闭掉打开的命名管道的文件描述符
close(fd);
// 父进程等待子进程
for(int i = 0; i < NUM; ++i)
{
waitpid(-1, nullptr, 0);
Log("等待子进程成功", DEBUG) << "第 " << i << "个进程" << endl;
}
// last. 删除命名管道
if(unlink(PATH_NAME) < 0)
{
perror("unlink");
exit(2);
}
// 删除成功
Log("delete 命名管道 success~", DEBUG) << endl;
return 0;
}-
client编写
#include"Common.hpp"
#include<fcntl.h>
int main()
{
//1. 打开与Server相同的命名管道
int fd = open(PATH_NAME, O_WRONLY);
if(fd < 0)
{
perror("open");
exit(1);
}
Log("client open 命名管道 success~~", DEBUG) << "fd: " << fd << endl;
//2. 写入数据
string message;
while(true)
{
cout << "client input# ";
getline(cin, message);
write(fd, message.c_str(), message.size());
message.clear();
}
// last. 关闭文件描述符
close(fd);
Log("关闭命名管道~", DEBUG);
return 0;
}-
这里客户端只需要打开命名管道即可
-
打开后就可以向正常文件里面写入数据一样
-
然后客户端可以输入数据，向服务器发送
-
等最后只需要关闭掉文件描述符即可
-
客户端不需要删除命名管道，因为这是服务器创建的，所以交给服务器即可
管道总结
-
命名管道实际上和匿名管道差不多
-
匿名管道是操作系统帮我们创建的一个系统级别的文件，没有名字，所以只能通过父子进程继承的方式来获得文件描述符
-
命名管道索然也是系统帮我们创建的，但是是有名字的，所以可以由没有关系的进程打开来共享，所以命名管道即使是不相关的进程也可以通信
-
而匿名管道和命名管道是差不多的，只是实现进程看到同一份资源的手段不同而已
System V
-
system v 是共享内存，也就是让不同的进程看到同一块内存
-
而我们知道由于页表和 mmu 可以随便隐射的关系，所以可以将共享内存给隐射到两个进程的地址空间上
-
而我们知道在进程的地址空间里面的堆栈中的一大段镂空实际上就是共享区，而一般共享内存都会隐射到这里
-
所以当两个进程看到同一份内存的时候，就可以通信了
-
而既然是共享内存，那么是不是可能每一个进程都可能创建一个共享内存？
-
既然是每一个进程都可能会创建，那么操系统要不要管理起来？
-
当然需要管理起来，那么如何管理？ 先描述，再组织！！！
-
实际上，共享内存的生命周期是随内核的，而并不是bash，所以如果我们创建了共享内存，但是不释放，那么就会导致内存泄露的问题。
下面看一下如何申请共享内存：
申请共享内存
NAME
shmget - allocates a System V shared memory segment
SYNOPSIS
#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);-
这个函数就是申请一段共享内存
-
第二个参数就是表示申请的共享内存的大小（这个大小一般都是页（page）的整数倍）一页就是 4096 字节
-
第三个参数就是这个共享内存的打开创建方式
-
IPC_CREAT：表示如果没有的话，那么就创建一个共享内存，如果有的话，那么就返回以及有了的共享内存
-
IPC_EXCL：这个参数单独使用时没有任何意义的，需要和 IPC_CREAT 配合使用，那么配合使用的效果就是，如果没有这个共享内存，那么就申请一段返回，如果有的话，那么就出错返回
-
-
那么第一个参数是什么呢？
-
第一个参数就是如果使用相同的 key 那么看到的共享内存是相同的，而这个基本需要唯一的，但是并不需要我们自己搞，我们有一个函数，可以获得这个值。
获取 key
NAME
ftok - convert a pathname and a project identifier to a System V IPC key
SYNOPSIS
#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id);-
该函数就是获取一个 shmget 函数的第一个参数 key
-
这个函数就是可以生成一个唯一值，但是不一定唯一，所以可能会出错
-
path_name 就是传入一个文件的路径，这个文件一定需要有权限
-
第二个参数就是传入一个值范围0~255
-
返回值就是 key ，也就是 shmget 函数所需要的参数
-
如果返回-1 表示失败了
申请内存
这个是头文件
//Common.hpp
#include<iostream>
using namespace std;
#include<sys/types.h>
#include<sys/stat.h>
#include<sys/wait.h>
#include<unistd.h>
#include<string>
#include"Log.hpp"
#include<sys/ipc.h>
#include<sys/shm.h>
#define PATH_NAME "name_pipe"
#define MODE 0666
#define KEY_PATH "."
#define PROJ_ID 66
#define SHM_SIZE 4096
//所以申请内存一定需要 key ，所以需要先获取一个 key
// 1. 获取 key
// Common.hpp
int getKey()
{
int k = ftok(KEY_PATH, PROJ_ID);
if(k == -1)
{
perror("ftok");
exit(1);
}
Log("get key success~", DEBUG) << "key: " << k << endl;
return k;
}
// 2. 申请空间
int getShm(int key, size_t size = SHM_SIZE)
{
int shmid = shmget(key, size, IPC_CREAT | IPC_EXCL);// 这里保证服务器申请的共享内存一定是最新的
if(shmid == -1)
{
perror("shmget");
exit(2);
}
Log("allocate shared memory success~", DEBUG) << "shmid: " << shmid << endl;
return shmid;
// Server.cc
int main()
{
// 1. 获取 key
int key = getKey();
sleep(10);
// 2. 获取一段共享内存
int shmid = getShm(key);
sleep(10);
return 0;
}-
上面就是获取一段共享内存
-
下面我们运行这段代码看一下
在这之前，我先说一下手动查看共享内存的指令
ipcs -m下面看一下运行这段代码：
[lxy@hecs-348468 shm]$ ipcs -m
------ Shared Memory Segments --------
key shmid owner perms bytes nattch status
[lxy@hecs-348468 shm]$ ipcs -m
------ Shared Memory Segments --------
key shmid owner perms bytes nattch status
0x42010b64 4 lxy 0 4096 0 -
上面就是 ipcs -m 查到的内容，下面我们介绍一下这些字段
-
key 就是这个共享内存的 key 也就是我们最开始获取的 key
-
shmid 就是共享内存的 id 也就是 shmget 的返回值
-
owner 就是拥有者
-
perms 就是权限，类似文件一样，有没有权限，如果没有权限的话，那么是不可以访问等等的
-
bytes 就是这个共享内存的大小，我们上面设置了 4096 而且页推荐 4096 的整数倍
-
nattch 就是这个共享内存和几个进程在关联
-
status 就是状态：如果不显示就是正常的，显示 dest 表示被删除了，但是还有人在使用
-
上面的perm(权限)，我们看到我们申请的共享内存的权限是0，表示没有权限，所以我们需要在申请的时候加上亲我们的权限！
-
nattch 就是共享内存与进程的关联数，其中，只有共享内存是不够的，还是需要关联起来，也就是我们前面说的需要将共享内存通过页表+MMU映射到对应进程的共享区，而这个也是一个函数
关联共享内存
NAME
shmat, shmdt - System V shared memory operations
SYNOPSIS
#include <sys/types.h>
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);-
这个函数就是用来将共享内存和进程关联起来的
-
其中第一个参数就是 shmid 也就是我们 shmget 的返回值
-
第二个参数是一个地址，表示我们想要将共享内存映射到进程地址空间的哪一个位置，但是这里不建议我们自己搞，因为我们页不知道进程地址空间里面的哪一些地址我们已经使用了，所以这里建议直接传 nullptr
-
第三个参数表示权限，这里默认为0即可，0就是读写权限，如果给了 SHM_RDONLY 那么表示以只读
-
返回值，如果是-1，表示返回失败，否则返回一个地址，也就是共享内存的地址
去关联共享内存
当然不能值关联共享内存，还需要可以去关联共享内存
NAME
shmat, shmdt - System V shared memory operations
SYNOPSIS
#include <sys/types.h>
#include <sys/shm.h>
int shmdt(const void *shmaddr);-
该函数时用来去关联共享内存的
-
如果不去关联共享内存，直接删除的话时有问题的
-
这个函数的参数就是 shmat 的返回值
-
如果返回值是 -1 表示失败
删除共享内存
-
删除共享内存有两种做法：
-
手动删除
-
代码删除
-
-
手动删除的指令是：ipcrm -m shmid
-
但是手动删除不方便，我们还是让共享内存在不使用后就删除掉即可，所以还是在代码里面删除
NAME
shmctl - System V shared memory control
SYNOPSIS
#include <sys/ipc.h>
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);-
这个函数可以用来删除共享内存，但是还有其他的功能，不过今天只用来删除共享内存
-
第一个参数就是 shmget 的返回值
-
第二个就是操作，既然我们是用来删除的，所以我们只需要传入 IPC_RMID 表示删除共享内存
-
最后一个参数是一个输出型参数，而我们知道共享内存也是一个数据结构，我们可以通过这个参数获取到这个共享内存的信息，包括最后一次访问等等...
-
不过既然是删除，所以我们也不需要获取
-
返回值是 -1 表示返回失败
下面看一下如何实现：
// 关联共享内存
char* attach(int shmid)
{
char* address = (char*)shmat(shmid, nullptr, 0);
if(address == nullptr)
{
perror("shmat");
exit(3);
}
Log("attach shared memory to shared Area success~", DEBUG) << endl;
return address;
}
// 去关联共享内存
void detach(char* address)
{
int r = shmdt(address);
if(r < 0)
{
perror("shmdt");
exit(4);
}
Log("detach shared memeory success~", DEBUG) << endl;
}
// 删除共享内存
void delShm(int shmid)
{
int r = shmctl(shmid, IPC_RMID, nullptr);
if(r < 0)
{
perror("shmctl");
exit(5);
}
Log("delete shared memory success~", DEBUG) << endl;
}-
但是实际上，我们现在的共享内存是关联不成功的，为什么？
-
还记得我们前面说的我们申请的共享内存是需要权限的，否则无法进行下一步操作，如果没有权限的话，即使关联了，对应的共享内存也不会显示关联数的
-
所以我们需要在获取共享内存的时候加上权限
int getShm(int key, size_t size = SHM_SIZE)
{
int shmid = shmget(key, size, IPC_CREAT | IPC_EXCL| 0666);// 这里或 0666 表示我们给的权限
if(shmid == -1)
{
perror("shmget");
exit(2);
}
Log("allocate shared memory success~", DEBUG) << "shmid: " << shmid << endl;
return shmid;
}-
如果这样获取那么就可以了
-
所以下面看一下我们的 Server.cc 的整体大逻辑
#include"Common.hpp"
#include<fcntl.h>
#define SIZE 128
#define NUM 3
int main()
{
// 1. 获取 key
int key = getKey();
sleep(10);
// 2. 获取一段共享内存
int shmid = getShm(key);
sleep(10);
// 3. 将共享内存关联到该进程的共享区
char* address = attach(shmid);
// address 是返回的地址
// 4. 使用共享内存通信
sleep(10);
// 5. 将共享内存去关联
detach(address);
sleep(10);
// last. 删除共享内存
delShm(shmid);
return 0;
}这里呢！我们让服务器区申请共享内存和删除共享内存，而客户端需要使用相同的获取key的算法来获取一个key，然后使用 shmget 获取到同一块共享内存，这里我们只需要IPC_CREAT，并不需要IPC_EXCL
获取到后，客户端也需要关联共享内存，同时使用结束后需要去关联，但是客户端不需要管这块共享内存的管理工作，删除交给服务器即可！
#include"Common.hpp"
#include<fcntl.h>
int main()
{
// 1. 客户端获取 key(使用和服务器获取 key 相同的算法)
int key = getKey();
// 2. 客户端获取共享内存，这里客户端只需要获取到服务器申请好的共享内存即可
int shmid = shmget(key, SHM_SIZE, IPC_CREAT);
if(shmid < 0)
{
perror("shmget");
exit(2);
}
Log("client get shared memory success~", DEBUG) << endl;
// 3. 客户端关联共享内存
char* address = attach(shmid);
// 4. 使用共享内存
// 5. 去关联共享内存
detach(address);
// 6. 客户端不需要参与共享内存的管理工作，共享内存的管理工作由服务器程序管理
return 0;
}通信
在共享内存这里，我们和前面的文件是不同的，前面的文件需要调用 read 或 write 接口，但是在共享内存这里，我们可以直接将数据拷贝到共享内存中，所以共享内存是进程间通信速度最快的，如果是文件的话，那么还是需要经历内核缓冲区等拷贝。
所以下面我们看一下共享内存进行进程间通信
我们可以让client将数据拷贝到共享内存
// 通信步骤
void receiveMessage(char* address)
{
while(true)
{
Signal::wait(fd);
printf("client say> %s", address);
sleep(1);
}
}
int main()
{
Signal sig;
// 0. 获取信号
int fd = open(PATH_NAME, O_RDONLY);
if(fd < 0)
{
perror("open");
exit(1);
}
Log("server open name_pipe success~", DEBUG) << endl;
// 1. 获取 key
int key = getKey();
// 2. 获取一段共享内存
int shmid = getShm(key);
// 3. 将共享内存关联到该进程的共享区
char* address = attach(shmid);
// address 是返回的地址
// 4. 使用共享内存通信
receiveMessage(address);
// 5. 将共享内存去关联
detach(address);
// last. 删除共享内存
delShm(shmid);
return 0;
}我们这里让服务器直接进行打印共享内存中的数据，以字符串的方式，我们也同时让client以字符串的方式进行写入：
// 发送数据
void sendMessage(char* address)
{
string message;
message += "I am client: 这是第 ";
int size = message.size();
int count = 0;
while(true)
{
message += to_string(count++);
message += " 条消息";
sprintf(address,"%s\n", message.c_str());
sleep(1);
message.resize(size);
}
}
int main()
{
// 0. 获取fd
int fd = open(PATH_NAME, O_WRONLY);
if(fd < 0)
{
perror("open");
exit(1);
}
Log("获取信号成功", DEBUG) << endl;
sleep(1);
// 1. 客户端获取 key(使用和服务器获取 key 相同的算法)
int key = getKey();
// 2. 客户端获取共享内存，这里客户端只需要获取到服务器申请好的共享内存即可
int shmid = shmget(key, SHM_SIZE, IPC_CREAT);
if(shmid < 0)
{
perror("shmget");
exit(2);
}
Log("client get shared memory success~", DEBUG) << endl;
// 3. 客户端关联共享内存
char* address = attach(shmid);
// 4. 使用共享内存
sendMessage(address);
// 5. 去关联共享内存
detach(address);
// 6. 客户端不需要参与共享内存的管理工作，共享内存的管理工作由服务器程序管理
return 0;
}客户端这里一直将数据流拷贝到共享内存中，只要拷贝到内存中，那么对方进程就可以考到我们发送的数据。
但是上面我们的通信是没有经过控制的，由于我们直接向内存中写如数据，所以两个进程是可能client写了一半，但是server就已经读取了，所以是没有访问控制的，那么如果想要实现访问控制那么应该怎么做呢？可以通过命名管道！！！
但是我们下面并不会写命名管道控制的代码，因为我们前面已经看过命名管道了~
但是我们可以简单的介绍一下：
-
第一步可以让服务器创建一个命名管道，然后此时服务器和客户端都可以打开这个文件描述符
-
打开后，我们可以让服务器读取数据，如果命名管道里面没有数据的话，那么此时服务器程序就会阻塞。
-
我们可以让客户端向命名管道里面写入数据，如果写入了数据，那么服务器程序就会从阻塞中被唤醒。
-
所以我们可以等客户端程序将想要写入共享内存中的数据写完之后，然后客户端程序向命名管道里面写入数据。
-
在服务器程序读取数据之前，可以先调用read读取命名管道，如果没有数据就会阻塞，只要有数据了就会被唤醒，当服务器被唤醒，说明客户端程序一定写入了数据，说明客户端已经把想要写入共享内存的数据写入完毕。
-
此时就实现了共享内存的访问控制。
扫一扫
165
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
