实体之间的联系实际上反映了实体之间的语义关系。联系也是实体，因此它也可以有属性。实体间联系情况比较复杂，就其联系方式来说，我们可把它分为以下三种：
1)：一对一联系(简记1:1)
　　若两个同型实体集中，一方的一个实体唯一与另一方的一个实体相对应，则称为1:1联系。(如班级和正班长关系：假设一个班只有一个正班长。)
2)：一对多联系(简记1:n)　 

　　若两个不同型的实体集中，一方一个实体对应另一方多个实体；反之另一方一个实体最多只与本方一个实体相对应，称1:n联系。(如班级和学生关系。)
3)：多对多联系(简记m:n) 


•
　　多对多模式需要在A表和B表之间有一个关联表，这个关联表也是“多对多模式”的核心所在。
　　若两不同型实体集中，任何方一个实体都与对方一个或多个实体相对应，称m :n联系。(如学生与课程的关系。)
 

《使用属性嵌入实现知识图谱间的实体对齐》
Entity Alignment between Knowledge Graphs Using Attribute Embedding
一、简介
随着知识图谱的发展和应用，有许多的知识图谱被创建并应用于不同的目标。这些图谱可能是互补的，如果可以将这些图谱融合为一个更大的图谱，那么就能改善下游基于知识图谱的应用。将这些知识图谱集成为统一图谱的主要挑战之一就是实体对齐(Entity Alignment)。
在实际应用中，知识图谱通常被保存在$\text{RDF}$三元组中。$\text{RDF}$三元组的形式为

$\langle subject, relationship/predicate,object\rangle$

其中，$subject$表示实体，$object$表示实体或者属性值。若$object$为实体，那么称该三元组为关系三元组；若$object$为属性三元组，则该三元组称为属性三元组。
最近，有许多基于嵌入的实体对齐方法被提出，而这些方法是建立在知识图谱嵌入模型的基础上(例如$\text{TransE}$)。$\text{TransE}$能够学习关系三元组知识图谱中实体的嵌入向量，并且该向量能够捕获到实体间的语义相似性。但是，$\text{TransE}$无法直接应用于实体对齐。因为，只有两个知识图谱的嵌入向量落入相同的向量空间，才能使用那些向量进行实体对齐。为了解决这个问题，先前的研究提出分别学习两个知识图谱的嵌入向量，然后使用一个映射矩阵将一个图谱的嵌入向量映射到另一个图谱的空间中。但是，这种方法非常依赖大量的种子对齐实体。然而，种子对齐实体通常很难获得。
论文提出了一种新的嵌入模型来解决上面的限制。首先，从图谱的属性三元组中生成属性嵌入向量；然后，使用属性嵌入向量将两个知识图谱的实体迁移至相同的向量空间。

论文作者观察到，许多知识图谱包含大量的属性三元组，但是目前的实体对齐方法并没有利用起来。例如，在知识图谱$DBpeida$、$YAGO$、$LinkedGeoData$、$Geonames$，分别包含47.62%、62.78%、94.66%和76.78%的属性三元组。

论文贡献：

提出了一种实体对齐框架，其由一个predicate alignment模块、embedding learning模块和entity alignment模块组成。
提出了一种新颖的嵌入向量学习模型，能够将实体嵌入向量和属性嵌入向量相结合，从而为不同的知识图谱生成统一的嵌入空间。
论文在三个数据集上进行了评估，结果显示state-of-the-art。

二、预备知识
一个知识图谱$G$通常是由关系三元组和属性三元组组成。关系三元组的形式为$\langle h,r,t\rangle$，其中$r$是两个实体$h$和$t$间的关系。属性三元组的形式为$\langle h,r,a\rangle$，其中$a$是实体$h$在属性$r$上的取值。
给定两个知识图谱$G_1$和$G_2$，实体对齐任务的目标是寻找匹配实体对$\langle h_1,h_2\rangle$，其中$h_1\in G_1,h_2\in G_2$，$h_1$和$h_2$表示现实世界中的同一实体。图谱嵌入方法会为三元组中每个元素分配一个连续的向量表示，形式为$\langle\textbf{h,r,t}\rangle$和$\langle\textbf{h,r,ta}\rangle$，其中黑体表示对应元素的向量表示。
1. TransE
许多基于嵌入的实体对齐算法均是基于TransE，这里对算法TransE进行简单的介绍并说明该方法面临的限制。
给定一个关系三元组$\langle h,r,t\rangle$，算法TransE假设实体$t$的嵌入向量应该与实体$h$的嵌入向量加上关系$r$嵌入向量接近，即$\textbf{h+r}\approx\textbf{t}$。通过这样的方法得到的嵌入向量会保存实体的结构信息，即在共享相似邻居结构的实体，其向量表示也相近。这种能够保存结构信息的嵌入向量，称之为结构嵌入。
TransE通过最小化下面的loss来实现结构嵌入：

$\begin{aligned}
&J_{SE}=\sum_{t_r\in T_r}\sum_{t'_r\in T'_r}\text{max}(0,[\gamma+f(t_r)-f(t'_r)])\\
&T_r=\{\langle h,r,t\rangle|\langle h,r,t\rangle\in G\};f(t_r)=||\textbf{h+r-t}||
\end{aligned}$

其中，$||\textbf{x}||$表示向量$\textbf{x}$的L1范数，$\gamma$是一个边界超参，$T_r$是训练数据集中的有效关系三元组集合，$T'_r$是无效关系三元组集合，$E$是$G$中的实体集合。

$T'_r=\{\langle h',r,t\rangle\|h'\in E\}\cup\{\langle h,r,t'\rangle|t'\in E\}$

将有效三元组集合$T_r$中的头实体或者尾实体进行随机替换，从而生成无效三元组集合$T'_r$。

TransE会为关系三元组中的每个实体生成一个低维且连续的向量，该向量保存了知识图谱中的隐含语言信息。例如，实体$dbp:Germany$的嵌入向量与$dbp:France$接近，因为这两个实体都是欧洲的国家且具有相似的相邻实体类型(例如president、continet等)。
对于实体对齐任务来说，直接使用TransE是有局限性的。具体来说，不同图谱上获得的嵌入向量可能会落入不用的向量空间，导致相似度无法直接计算。目前，通过计算转换矩阵来解决该问题的方法需要依赖大量的种子对齐实体。这种方法不容易扩展且非常容易收到种子对齐实体质量的影响。

三、解决方案概述

整个解决方案如图1所示，其由三部分组成，分别为：predicate alignment模块、embedding learning模块、entity alignment模块。

为了使两个知识图谱的关系三元组嵌入向量具有统一的向量空间。predicate alignment模块将两个知识图谱中相似的predicate进行了合并。例如，$dbp:bornIn$和$yago:wasBornIn$，这里会使用统一的命名规则将两者合并为$bornIn$。基于predicate的合并，可以将两个知识图谱$G_1$和$G_2$合并为$G_{1\_2}$。然后再将$G_{1\_2}$划分为关系三元组集合$T_r$和属性三元组集合$T_a$，用于后面嵌入向量的学习。
embedding learning模块会将结构嵌入和属性嵌入进行联合学习，从而获得统一向量空间下的实体嵌入向量。具体来说，结构嵌入向量使用关系三元组$T_r$来学习，属性嵌入使用属性三元组$T_a$来学习。初始时，来自$G_1$和$G_2$实体的结构嵌入会落入不同的向量空间，因为两个图谱的命名规则不同。相反，从属性三元组$T_a$中学习到的属性嵌入能够落入相同的向量空间，因为这个属性嵌入是基于字符嵌入获得的。最终，通过属性嵌入将实体的结构嵌入转换至统一的向量空间中。这样就能够使用向量相似度来捕获图谱间的实体相似度。
在拥有了$G_1$和$G_2$中所有实体的嵌入向量，那么entity alignment模块就能够发现匹配实体对$\langle h_1,h_2\rangle$，其中$h_1\in G_1$并且$h_2\in G_2$。具体来说，相似度大于阈值$\beta$，则认为两实体相同。
此外，为了进一步改善模型的效果，论文还使用关系传递规则来进一步丰富实体的属性，帮助模型构建更加健壮的属性嵌入向量。

四、Predicate Alignment模块
predicate alignment模块通过重命名两个知识图谱的predicate来实现两图谱的合并，这样就可以使关系的嵌入向量落入统一的向量空间。具体来说，通过一些predicate的命名规则可以将两个predicate进行统一。另外，还有一部分predicate可以通过部分匹配的方式来识别，例如$dbp:diedIn$和$yago:diedIn$或者$dbp:bornIn$和$yago:wasBornIn$，可以通过编辑距离计算两个predicate最后部分内容的相似度，并设阈值为0.95，从而进一步对齐不同的predicate。
五、Embedding Learning模块
1.结构嵌入(Structure Embedding)
论文在TransE的基础上进行了改进，使得模型更加聚焦在predicate已经对齐的三元组上，从而使模块能够获得有益于实体对齐的嵌入向量。具体来说，通过添加权重$\alpha$来控制嵌入向量的学习，目标函数为

$\begin{aligned}
&J_{SE}=\sum_{t_r\in T_r}\sum_{t'_r\in T'_r}\text{max}(0, \gamma+\alpha(f(t_r)-f(t'_r)))\\
&\alpha=\frac{count(r)}{|T|}
\end{aligned}$

其中，$T_r$是有效关系三元组集合，$T'_r$是无效关系三元组集合，$count(r)$是关系$r$出现的次数，$|T|$是合并知识图谱$G_{1\_2}$中三元组的总数量。
直觉上，已经对齐的predicate出现次数会高于未对齐的predicate。因为对齐的predicate在两个知识图谱中均有出现，这样就能使模型更加聚焦在对齐的三元组上。
2.属性字符嵌入(Attribute Character Embedding)
类似于TransE，这里将$r$看作是头实体$h$到属性值$a$的翻译。但是，相同的属性值$a$可能以不同的形式出现在不同的知识图谱中，例如实体的纬度50.9989和50.99888889、人名"Barack Obama" 和"Barach Hussein Obama"。因此，这里使用组合函数来编码属性值，并进一步定义出三元组中每个元素间的关系，即$\textbf{h+r}\approx f_a(a)$。$f_a(a)$是一个组合函数，$a=\{c_1,c_2,\dots,c_t\}$是属性值的字符序列。组合函数能够将属性值编码成一个单独的向量，并将相似的属性值映射到相似的向量表示上。
论文定义了三种组合函数：


$\text{sum compositional function}(\textbf{SUM})$
该组合函数会将属性值的所有字符向量相加，

$f_a(a)=\textbf{c}_1+\textbf{c}_2+\dots+\textbf{c}_t$

其中，$\textbf{c}_1,\textbf{c}_2,\dots,\textbf{c}_t$是属性值的字符向量。但是，该组合函数存在一个问题。若两个属性值包含同样的字符集但顺序不同，该组合函数仍然会为这两个属性值分配相同的向量表示。例如坐标"50.15"和"15.05"会有相同的向量表示。


$\text{LSTM-based compositional function}(\textbf{LSTM})$
为了解决$\textbf{SUM}$的问题，提出了基于LSTM的组合函数。该组合函数使用LSTM来编码字符序列至单个向量，并使用最终的hidden state作为整个属性值的向量表示。

$f_a(a)=f_{lstm}(\textbf{c}_{1},\textbf{c}_{2},\dots,\textbf{c}_t)$

其中，$f_{lstm}$表示LSTM网络。


$\text{N-gram-based compositional function}(\textbf{N-gram})$
除了使用LSTM以外，还提供了一种基于N-gram的可选组合函数。

$f_a(a)=\sum_{n=1}^N\Big(\sum_{i=1}^t\frac{\sum_{j=i}^n\textbf{c}_j}{t-i-1}\Big)$

其中，$N$是n-gram中$n$的上限(论文实验中$N=10$)，$t$是属性值的长度。


最后，为了能够学习得到属性字符的嵌入向量，最小化目标函数$J_{CE}$，

$\begin{aligned}
&J_{CE}=\sum_{t_a\in T_a}\sum_{t'_a\in T'_a}\text{max}(0, [\gamma+\alpha(f(t_a)-f(t'_a))])\\
&T_a=\{\langle h,r,a\rangle\in G\};f(t_a)=||\textbf{h+r}-f_a(a)||\\
&T'_a=\{\langle h',r,a\rangle|h'in E\}\cup\{\langle h,r,a'\rangle|a'\in A\}
\end{aligned}$

其中，$T_a$是训练数据中的有效属性三元组集合，$T'_a$是无效属性三元组集合，$A$是$G$中属性集合。无效三元组集合通过随机替换有效三元组的头实体或属性值来生成。$f(t_a)$是基于$h$、$r$和$f_a(a)$的可信评分函数。
3. 联合学习两种嵌入
除了用于学习结构的$J_{SE}$以及学习属性的$J_{CE}$，还需要将两者进行联合学习。即使用属性字符嵌入向量$\textbf{h}_{ce}$将结构嵌入向量 $\textbf{h}_{se}$转换到相同的向量空间，

$J_{SIM}=\sum_{h\in G_1\cup G_2}[1-cos(\textbf{h}_{se},\textbf{h}_{ce})]$

其中，$cos(\textbf{h}_{se},\textbf{h}_{ce})$是向量$\textbf{h}_{se}$和$\textbf{h}_{ce}$的cosine相似度。
直觉上，两图谱的$\textbf{h}_{ce}$会直接落入相同的向量空间，$\textbf{h}_{se}$则相反。使用$J_{SIM}$约束两者相似，将会使两图谱的$\textbf{h}_{se}$也落入相同的向量空间。
最终的联合学习目标函数为

$J=J_{SE}+J_{CE}+J_{SIM}$
六、Entity Alignment模块
基于embedding learning学习到的嵌入向量能够令$G_1$和$G_2$中的相似实体具有相似的嵌入向量，所以最终的嵌入向量能够用于实体对齐。具体来说，计算下面的值

$h_{map}=\mathop{\text{argmax}}_{h_2\in G_2}cos(\textbf{h}_1,\textbf{h}_2)$

若给定一个实体$h_1\in G_1$，那么计算$h_1$和所有实体$h_2\in G_2$的相似度，并将大于阈值$\beta$的实体对作为对齐实体，即
$\langle h_1,h_{map}\rangle$是对齐实体。
七、通过传递性规则来增强三元组
即使结构嵌入能够隐含的学习关系传递的信息，显式地将这些关系传递的信息添加至属性中，也依然能够帮助改进实体间相似度的计算。
例如，给定三元组
$\langle dbp:Emporium_Tower,:locatedIn, dbp:London\rangle$和$\langle dbp:London,:country,dbp:England\rangle$
那么可以推断出，$\text{dbp:Emporium\_Tower}$和$\text{dbp:England}$有关系。事实上，这个信息能够用来丰富实体$\text{dbp:Emporium\_Tower}$。
具体来说，按照如下的规则来利用一跳关系：

给定一对具有传递关系的三元组$\langle h_1,r_1,t\rangle$和$\langle t,r_2,t_2\rangle$，将$r_1.r_2$作为头实体$h_1$和尾实体$t_2$的关系。那么可以定义一个类似TransE的向量间关系：$\textbf{h}_1+(\textbf{r}_1.\textbf{r}_2)\approx\textbf{t}_2$。这样，若存在传递三元组，则将模板函数中公式$(4)$和$(9)$中的关系向量$\textbf{r}$替换为$\textbf{r}_1.\textbf{r}_2$。

参考链接：阿里云，百度百科
一、实体类（百度百科）

实体类主要是作为数据管理和业务逻辑处理层面上存在的类别； 它们主要在分析阶段区分 实体类的主要职责是存储和管理系统内部的信息，它也可以有行为，甚至很复杂的行为，但这些行为必须与它所代表的实体对象密切相关。

二、领域模型中的实体模型
实体类分为四种类型：VO、DTO、DO、PO，各种实体类用于不同业务层次间的交互，并会在层次内实现实体类之间的转化。


业务分层为：视图层（VIEW+ACTION），服务层（SERVICE），持久层（DAO）


Entity（PO）　每个属性基本上都对应数据库表里面的某个字段。完全是一个符合Java Bean规范的纯Java对象，没有增加别的属性和方法。


VO：值对象(Value Object)，通常用于业务层之间的数据传递，和Entity一样也是仅仅包含数据而已。但应是抽象出的业务对象，可以和表对应，也可以不，这根据业务的需要。


VO：表现层对象(View Object)，主要对应展示界面显示的数据对象，用一个VO对象来封装整个界面展示所需要的对象数据。


DTO：数据传输对象(Data Transfer Object)，是一种设计模式之间传输数据的软件应用系统。


直白说，就是简取PO对象的部分数据，进行数据的再封装


此时，如果这个对象用来对应界面的展现，就叫VO。


三、模型展示

进程是一个实体，两个实体间的通信就需要介质。使用不同的介质，就对应了不同的通信方式。进程的通信方式分为两种，同主机和不同主机。下面我们来逐个分析。
1 匿名管道
匿名管道是进程间通信中比较简单的一种，他只用于有继承关系的进程，因为匿名，非继承关系的进程无法找到这个管道，也就无法完成通信，而有继承关系的进程，是通过fork出来的，父子进程可以获得得到管道。进一步来说，子进程可以使用继承于父进程的资源，但是他无法使用叔伯进程的资源。管道通信的原理如下。



父子进程通过fork后，子进程继承了父进程的文件描述符。所以他们指向同一个数据结构。父子进程通常只需要单向通信，父子进程各关闭自己的一端。当父子进程对管道进程读写的时候，操作系统会控制这一切，包括数据的读取和写入，进程的挂起和唤醒。
2 命名管道
正如1中所说，匿名管道可以完成进程间通信，但是他有一定的限制，他的限制来自于他是匿名的，所有其他进程无法找到他，命名管理就是用来解决这个问题。有名字，进程们就可以通过名字去找到这个管道来通信。原理如下。



首先创建一个文件名为my_fifo的文件，然后进程们以读或写的方式去打开这个文件（以什么方式打开则具有对应的能力）。因为一个文件对应一个inode，所以不同的文件以同样的文件名打开一个文件时，他指向的inode是一样的。所以这个inode就是进程间通信的介质。他指向一块内存用于通信。然后其他的就和匿名管道一样了。
3 消息队列
进程间通信的前提是需要共享介质，所以不同的进程间通信，就是找到不同的共享介质。消息队列的原理就是操作系统维护一块数据，然后各个进程通过key来换取一个id，后续通过id进行消息的存取。使用过程。
// 发送进程
msgid = msgget((key_t)1234, 0666 | IPC_CREAT);
msgsnd(msgid, (void *)&data, MAX_TEXT, 0)
// 接收进程
msgid = msgget((key_t)1234, 0666 | IPC_CREAT);
msgrcv(msgid, (void *)&data, BUFSIZ, msgtype, 0)



进程通过key可以获取或者创建（系统维护）一个msqid_ds结构体。然后操作系统会返回key对应的一个id。后续进程通过id对msqid_ds进行存取。msqid_ds是表示一个消息队列的管理者。各个进程使用一个msqid_ds进行通信。操作系统会有权限控制，大小控制等。
4 共享内存
共享内存的原理和消息队列类型，都是开辟一块内存作为通信的介质。

共享内存的使用步骤。
// 通过key拿到一个id，每个进程都通过同样的key则可以得到同样的id
id= shmget((key_t)key, ...);
/*
	挂载到进程的地址空间，我们知道进程的地址是使用vma管理的，
	这里就是插入一个新的vma，拿到共享内存的首地址address,
	接下来就可以对这块内存进行读写了。
*/
address = shmat(shmid, 0, 0);
// 操作
// 从进程地址空间剥离出来，即不再使用这个空间
shmdt(shm);

1 操作系统有一个全局的结构体数据，每次需要一块共享的内存时（shmget），从里面取一个结构体，记录相关的信息。并返回一个id。

2 调用shmat的时候传入shmget返回的id。shmat根据id找到对应的shmid_ds 结构体。新建一个vm_area_struct结构体。开始地址和结束地址根据shmid_ds 中的信息计算，也就是用户申请的大小。接着把vm_area_struct插入进程中管理vm_area_struct的avl树。并且把一些上下文信息保存到页表项。

3 进程访问共享内存范围中的地址时，触发缺页中断。

4 如果还没分配物理地址则分配，否则直接范围已经分配的地址。如果分配了物理地址，则把物理地址写入进程的页表项。下次就不会缺页中断了。

5 其他进程共享该块内存的时候，如果访问范围内的地址，处理过程是类似的。进程访问某一个地址，发生缺页中断，发现这时候共享内存已经映射了物理地址。最后改写自己的页表项。因为各个进程都对应同一块内存，所以操作的时候会互相感知，实现通信。


5 信号
信号通信是进程通信中最简单的一种，但是他所能携带的信息有限，他只是通知其他进程一个信号，而不能发送具体的数据。我们先看一下进程结构体中关于信号的字段。
struct task_struct {
	...
	// 收到的信号
	long signal;
	// 每个信号对应的处理函数和一些标记
	struct sigaction sigaction[32];
	// 当前屏蔽的信号
	long blocked;	
};

当一个进程发送一个信号给另一个进程的时候，会调用kill函数。我们看看这个函数的逻辑。
int sys_kill(int pid,int sig)
{
	struct task_struct **p = NR_TASKS + task;
	int err, retval = 0;
	/*
		 pid等于0则给当前进程的整个组发信号，大于0则给某个进程发信号，
		-1则给全部进程发，小于-1则给某个组发信号
	*/
	if (!pid) while (--p > &FIRST_TASK) {
		if (*p && (*p)->pgrp == current->pid) 
			if (err=send_sig(sig,*p,1))
				retval = err;
	} else if (pid>0) while (--p > &FIRST_TASK) {
		if (*p && (*p)->pid == pid) 
			if (err=send_sig(sig,*p,0))
				retval = err;
	} else if (pid == -1) while (--p > &FIRST_TASK)
		if (err = send_sig(sig,*p,0))
			retval = err;
	else while (--p > &FIRST_TASK)
		if (*p && (*p)->pgrp == -pid)
			if (err = send_sig(sig,*p,0))
				retval = err;
	return retval;
}

/*
  发送信号给进程sig是发送的信号，p是接收信号的进程，priv是权限，
  1是代表可以直接设置，比如给自己发信息，priv为0说明需要一定的权限
*/
static inline int send_sig(long sig,struct task_struct * p,int priv)
{
	if (!p || sig<1 || sig>32)
		return -EINVAL;
	// 这里使用euid，即进程设置了suid位的话，可以扩大权限，即拥有文件属主的权限
	if (priv || (current->euid==p->euid) || suser())
		p->signal |= (1<<(sig-1));
	else
		return -EPERM;
	return 0;
}

我们看到发送信号的逻辑很简单，收到判断要给哪些进程发送信号，然后判断有没有发送权限，最后修改另一些进程结构体中的signal字段。这就表示那些进程收到了信号。那么在某个时机，那些进程就会处理这个信号。这些时机包括，系统调用返回和时钟中断返回等。
6 socket
socket通信的原理比较简单，但是他的实现非常复杂，因为网络的情况比较多样复杂。socket通信的方式有基于连接和不基于连接的。不管是否基于连接，socket通信都是基于四元组（源ip、源端口、目的ip、目的端口）。

1 不基于连接，比如UDP，那两端就直接发送数据，对端接收就可以。

2 基于连接，基于连接的，流程会比较长，大概分为建立连接，通信，关闭连接三个步骤。

基于连接的进程间通信，首先需要有一个进程在监听某个端口（监听型socket），我们叫他为服务进程。如果哪个进程想和这个服务进程通信，那么就要先和服务进程完成三次握手。完成后，服务进程会新建一个通信型socket和客户进程进行数据通信。服务进程继续监听。
7 unix域
unix域是基于socket通信的一个特例，因为他的实现中使用了socket技术，但是他是基于单个主机上的进程间通信。因为在同一个主机内，所以就少了很多网络上的问题，那就减少了复杂度。unix域和传统的socket通信类型，服务器监听，客户端连接，由于在同主机，就不必要使用ip和端口的方式，浪费一个端口。unix域采用的是一个文件作为标记。大致原理如下。

1 服务器首先拿到一个socket结构体，和一个unix域相关的unix_proto_data结构体。

2 服务器bind一个文件。对于操作系统来说，就是新建一个文件，然后把文件路径信息存在unix_proto_data中。

3 listen

4 客户端通过同样的文件路径调用connect去连接服务器。这时候客户端的结构体插入服务器的连接队列，等待处理。

5 服务器调用accept摘取队列的节点，然后新建一个通信socket进行通信。

unix域通信本质还是基于内存之间的通信，客户端和服务器都维护一块内存，然后实现全双工通信，而unix域的文件路径，只不过是为了让客户端进程可以找到服务端进程。而通过connect和accept让客户端和服务器对应的结构体关联起来，后续就可以互相往对方维护的内存里写东西了。就可以实现进程间通信。


8 mmap
mmap可以映射文件，从而达到进程间通信的目前，mmap的原理是

1 打开一个文件，拿到一个文件描述符。

2  根据mmap的参数，申请一个vma结构体。并且传入fd表示映射文件。

3 把vma插入到调用进程的vma链表和树中。返回首地址（用户指定或者系统默认分配）。

4 用户通过3中返回的地址，进行内存的读写，这时候对应的是文件的读写。

5 另一个进程同样执行1-4的步骤，即有两个进程都映射到同一个文件。两个进程进行读写的时候，就完成了进程间通信。