linux系统进程通信管理

常见IPC

Linux环境下，进程地址空间相互独立，每个进程各自有不同的用户地址空间。任何一个进程的全局变量在另一个进程中都看不到，所以进程和进程之间不能相互访问，要交换数据必须通过内核，在内核中开辟一块缓冲区，进程1把数据从用户空间拷到内核缓冲区，进程2再从内核缓冲区把数据读走，内核提供的这种机制称为进程间通信（IPC，InterProcess Communication）。

常用的进程间通信方式有：
	① 管道 (使用最简单)
	② 信号 (开销最小)
    ③ 共享映射区 (无血缘关系)
	④ 本地套接字 (最稳定)

管道基础

管道是Linux进程间的一种通信方式，两个进程可以通过一个共享内存区域来传递信息，并且管道中的数据只能是单向流动的，也就是说只能有固定的写进程和读进程。
管道是一种最基本的IPC机制，作用于有血缘关系的进程之间，完成数据传递。调用pipe系统函数即可创建一个管道。有如下特质：

1. 其本质是一个伪文件(实为内核缓冲区) 
2. 由两个文件描述符引用，一个表示读端，一个表示写端。
3. 规定数据从管道的写端流入管道，从读端流出。
管道的原理: 管道实为内核使用环形队列机制，借助内核缓冲区(4k)实现。
管道可以分为两种类型：匿名管道和命名管道。

其缺点为：

1、读写数据过程中数据自己读不能自己写。
2、数据一旦被读走，便不在管道中存在，不可反复读取（类似水在水管之中的流动）
3、由于管道采用的半双工通信方式。因此数据只能在一个方向流动。
4、只能在有公共祖先的进程之间使用管道

常见的通信方式有，单工通信、半双工通信、全双工通信。

匿名管道

匿名管道只能在父子进程间通讯。
1、	管道内无数据时，读端会发生阻塞直到有数据可读
2、	管道数据满时，写端会发生阻塞，直到读端开始读取数据
3、	如果写端对应的文件描述符被关闭，read函数返回0，但可以将数据读完
4、	如果读端对应的文件描述符被关闭，在执行write函数时会产生SIGPIPE信号，其默认行为会导致当前进程终止

Pipe函数

创建管道
int pipe(int pipefd[2]); 成功：0；失败：-1，设置errno
管道创建成功以后，创建该管道的进程（父进程）同时掌握着管道的读端和写端。
pipe()函数用于在内核中创建一个管道，该管道一端用于读取管道中的数据，另一端用于将数据写入管道。在创建一个管道后，会获得一对文件描述符，用于读取和写入，然后将参数数组fd中的两个值传递给获取到的两个文件描述符，fd[0]指向管道的读端，fd[1]指向写端。
pipe()函数调用成功，返回值为0；否则返回-1，并且设置了适当的错误返回信息。此函数只是创建了管道，要想从管道中读取数据或者向管道中写入数据，需要使用read()和write()函数来完成。当管道通信结束后，需要使用close()函数关闭管道的读写端。

实现父子进程间通讯

1. 父进程调用pipe函数创建管道，得到两个文件描述符fd[0]、fd[1]指向管道的读端和写端。
2. 父进程调用fork创建子进程，那么子进程也有两个文件描述符指向同一管道。
3. 父进程关闭管道读端，子进程关闭管道写端。父进程可以向管道中写入数据，子进程将管道中的数据读出。由于管道是利用环形队列实现的，数据从写端流入管道，从读端流出，这样就实现了进程间通信。

#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include<stdlib.h>
#include<fcntl.h>
#include<sys/wait.h>
#include<sys/types.h>
#include<sys/stat.h>

int main() {
	int fd[2];
	if (pipe(fd) == -1) {
		fprintf(stdout, "Can not open pipe.\n");
		exit(1);
	}
	pid_t pid = fork();
	if (pid < 0) {
		fprintf(stdout, " failure\n");
	} else if (pid == 0) {  //子进程
		close(fd[0]);  //子进程关闭读端
		char str[] = "message";  //将"message"传递给父进程
		write(fd[1], str, strlen(str));
	} else {   //父进程
		close(fd[1]);  //父进程关闭写端
		char str[100];
		read(fd[0], str, 100);
		fprintf(stdout, "Parent: read data from pipeline (%s)", str);
	}
    return 0;
}

命名管道

命名管道本质上是一个管道文件，它基于文件系统来实现进程间的通信，其读写端进程可以不是父子进程的关系，只需要进程有权限访问该管道文件即可。需要注意的是，命名管道中的数据实际上是存储在内存中，管道文件在文件系统中相当于是一个标记。
其命名规则
在命令行界面通过命令mkfifo filename创建命名管道文件，可以指定其文件名
在程序内部调用mkfifo函数（定义于头文件sys/stat.h中），参数filename为管道文件路径，mode为管道文件读写权限：
例如：int mkfifo(const char *filename, mode_t mode);
命名管道的读写机制和匿名管道相似。
只不过在使用前我们需要调用open函数来打开管道文件，通过其返回的文件描述符来读写管道文件。

Mkfifo函数命名管道

使用mkfifo()函数创建的命名管道文件与前面介绍的管道通信相似，只是它们创建方式不同。访问命名管道文件与访问文件系统中的其他文件一样，都是需要首先打开文件，然后对文件进行读写数据。如果在命名管道文件中读取数据时，并没有其他进程向命名管道文件中写入数据，则会出现进程阻塞状态；如果在写入数据的同时，没有进程从命名管道中读取数据，也会出现进程阻塞状态。
用mkfifo()函数创建一个命名管道，命名管道文件路径
调用open()函数打开该命名管道文件，以读写的方式打开。
调用write()函数向文件写入信息"hello world", 同时调用read()函数读取该文件，输出到终端。
调用close()函数关闭打开的命名管道文件。

FIFO函数

FIFO
FIFO常被称为命名管道，以区分管道(pipe)。管道(pipe)只能用于“有血缘关系”的进程间。但通过FIFO，不相关的进程也能交换数据。
FIFO是Linux基础文件类型中的一种。但，FIFO文件在磁盘上没有数据块，仅仅用来标识内核中一条通道。各进程可以打开这个文件进行read/write，实际上是在读写内核通道，这样就实现了进程间通信。
创建方式：

1. 命令：mkfifo 管道名
	2. 库函数：int mkfifo(const char *pathname,  mode_t mode);  成功：0； 失败：-1
	一旦使用mkfifo创建了一个FIFO，就可以使用open打开它，常见的文件I/O函数都可用于fifo。如：close、read、write、unlink等。

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#define FIFO "/root/process/hello"

int main()
{
    int fd;
    int pid;
    char r_msg[BUFSIZ];
    if((pid = mkfifo(FIFO,0777))==-1) /*创建命名管道*/
    {
	perror("failed!");
	return 1;
    }
    else
    printf("success!\n");
    fd = open(FIFO, O_RDWR);  /*打开命名管道*/
    if(fd == -1)
    {
	perror("cannot open the FIFO");
	return 1;
    }
    if(write(fd,"hello world", 12) == -1)  /*写入消息*/
    {
	perror("write data error!");
	return 1;
    }
    else
    printf("write data success!\n");
    if(read(fd, r_msg, BUFSIZ) == -1)  /*读取消息*/
    {
	perror("read error!");
	return 1;
    }
    else
    printf("the receive data is:  %s\n",r_msg);
    close(fd);   /*关闭文件*/
    return 0;
}

管道的读写

使用管道需要注意以下4种特殊情况（假设都是阻塞I/O操作，没有设置O_NONBLOCK标志）：

1. 如果所有指向管道写端的文件描述符都关闭了（管道写端引用计数为0），而仍然有进程从管道的读端读数据，那么管道中剩余的数据都被读取后，再次read会返回0，就像读到文件末尾一样。
2. 如果有指向管道写端的文件描述符没关闭（管道写端引用计数大于0），而持有管道写端的进程也没有向管道中写数据，这时有进程从管道读端读数据，那么管道中剩余的数据都被读取后，再次read会阻塞，直到管道中有数据可读了才读取数据并返回。
3. 如果所有指向管道读端的文件描述符都关闭了（管道读端引用计数为0），这时有进程向管道的写端write，那么该进程会收到信号SIGPIPE，通常会导致进程异常终止。当然也可以对SIGPIPE信号实施捕捉，不终止进程。具体方法信号章节详细介绍。
4. 如果有指向管道读端的文件描述符没关闭（管道读端引用计数大于0），而持有管道读端的进程也没有从管道中读数据，这时有进程向管道写端写数据，那么在管道被写满时再次write会阻塞，直到管道中有空位置了才写入数据并返回。
   总结：

① 读管道：	1. 管道中有数据，read返回实际读到的字节数。
				2. 管道中无数据：
(1) 管道写端被全部关闭，read返回0 (好像读到文件结尾)
				 	(2) 写端没有全部被关闭，read阻塞等待(不久的将来可能有数据递达，此时会让出cpu)
    ② 写管道：	1. 管道读端全部被关闭， 进程异常终止(也可使用捕捉SIGPIPE信号，使进程不终止)
				2. 管道读端没有全部关闭： 
(1) 管道已满，write阻塞。
					(2) 管道未满，write将数据写入，并返回实际写入的字节数。

管道编程技术

dup函数和dup2函数

dup和dup2也是两个非常有用的调用，它们的作用都是用来复制一个文件的描述符。它们
常用来重定向进程的stdin、stdout和stderr。
函数的原形如下：

#include <unistd.h>   
int dup( int oldfd );   
int dup2( int oldfd, int targetfd )

利用函数dup，我们可以复制一个描述符。传给该函数一个既有的描述符，它就会返回一个新的描述符，这个新的描述符是传给它的描述符的拷贝。这意味着，这两个描述符共享同一个数据结构。
dup2函数跟dup函数相似，但dup2函数允许调用者规定一个有效描述符和目标描述符的id。dup2函数成功返回时，目标描述符（dup2函数的第二个参数）将变成源描述符（dup2函数的第一个参数）的复制品，换句话说，两个文件描述符现在都指向同一个文件，并且是函数第一个参数指向的文件。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main()
{
int pfds[2];
if ( pipe(pfds) == 0 ) ...{
if ( fork() == 0 ) ...{
close(1);
dup2( pfds[1], 1 );
close( pfds[0] );
execlp( "ls", "ls", "-1", NULL );
} else ...{
close(0); 
dup2( pfds[0], 0 );
 close( pfds[1] );    
 execlp( "wc", "wc", "-l", NULL );
}
}
return 0;
}

Open函数

open 函数用于打开和创建文件。

#include <fcntl.h>
int open(const char *pathname, int oflag, ... );
返回值：成功则返回文件描述符，否则返回 -1

对于 open 函数来说，第三个参数（…）仅当创建新文件时才使用，用于指定文件的访问权限位（access permission bits）。pathname 是待打开/创建文件的路径名（如 C:/cpp/a.cpp）；oflag 用于指定文件的打开/创建模式，这个参数可由以下常量（定义于 fcntl.h）通过逻辑或构成。

O_RDONLY	只读模式
O_WRONLY	只写模式
O_RDWR	 读写模式

打开/创建文件时，至少得使用上述三个常量中的一个。以下常量是选用的：

O_APPEND	 每次写操作都写入文件的末尾
O_CREAT	如果指定文件不存在，则创建这个文件
O_EXCL	 如果要创建的文件已存在，则返回 -1，并且修改 errno 的值
O_TRUNC	如果文件存在，并且以只写/读写方式打开，则清空文件全部内容
O_NOCTTY	如果路径名指向终端设备，不要把这个设备用作控制终端。
O_NONBLOCK	如果路径名指向 FIFO/块文件/字符文件，则把文件的打开和后继 I/O设置为非阻塞模式（nonblocking mode）

以下三个常量同样是选用的，它们用于同步输入输出

O_DSYNC	等待物理 I/O 结束后再 write。在不影响读取新写入的数据的前提下，不等待文件属性更新。
O_RSYNC		read 等待所有写入同一区域的写操作完成后再进行
O_SYNC	等待物理 I/O 结束后再 write，包括更新文件属性的 I/O

补充read函数和write函数用法

头文件

#include<unistd.h>

读函数read

ssize_t read(int fd,void *buf,size_t nbyte) 
read函数是负责从 fd中读取内容到buf中.成功时,read返回实际所读的字节数,如果返回的值是0,表示已经读到文件的结束了.
小于0表示出现了错误.如果错误为 EINTR说明读是由中断引起的, 如果是ECONNREST表示网络连接出了问题。

#include<stdio.h>
#include<stdlib.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<string.h>
int main()
{
        int file1;
        file1=open("./1.txt",O_RDWR);//以读写形式打开创建的文件
        lseek(file1,0,0);//将光标设置在文件开头
        char s3[128];
        int num=read(file1,s3,128);//第一个参数所读文件的文件标识符，第二个参数通常是一个字符数组
        //第三个参数所要读取的字节数，返回值是实际所读取的的字节数
        close(file1);//关闭文件
        printf("%s",s3);//文件已经被读入到了s3中，输出所读的文件
        return 0; 
}

写函数write

ssize_t write(int fd,const void *buf,size_t nbytes)

write函数将buf中的nbytes字节内容写 入文件描述符fd.成功时返回写的字节数.失败时返回-1. 并设置errno变量. 在网络程序中,当我们向套接字文件描述符写时有俩种可能.

1)write 的返回值大于0,表示写了部分或者是全部的数据. 
2)返回的值小于0,此时出现了错误.我们要根据错误类型来处理.  如果错误为EINTR表示在写的时候出现了中断错误。如果为EPIPE表示网络连接出现了问题(对方已经关闭了连接).
3)nbytes 可以大于实际能写入的大小，比如，缓冲区只能写入100，但却写入1000，前100个字节能写入成功。可利用这个特性加上移动指针反复写入

#include<stdio.h>
#include<stdlib.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<string.h>
int main()
{
        int file1;
        char s1[]="adcdefghijklmn";//创建字符数组
        file1=open("./1.txt",O_CREAT|O_EXCL,0644);//创建文件
        if(file1==-1)
        {
                perror("创建文件file1失败");

        }
        file1=open("./1.txt",O_RDWR);//打开文件
        if(file1!=-1)
        {
                printf("文件file1打开成功\n");
                write(file1,s1,strlen(s1));//写入文件
                printf("文件file1写入成功\n");
        }
        close(file1);
        return 0; 
}

存储映射I/O

存储映射I/O (Memory-mapped I/O) 使一个磁盘文件与存储空间中的一个缓冲区相映射。于是当从缓冲区中取数据，就相当于读文件中的相应字节。于此类似，将数据存入缓冲区，则相应的字节就自动写入文件。这样，就可在不适用read和write函数的情况下，使用地址（指针）完成I/O操作。
使用这种方法，首先应通知内核，将一个指定文件映射到存储区域中。这个映射工作可以通过mmap函数来实现。

mmap函数

1、将一个普通文件映射到内存中，通常在需要对文件进行频繁读写时使用，这样用内存读写取代I/O读写，以获得较高的性能；
2、将特殊文件进行匿名内存映射，可以为关联进程提供共享内存空间；
3、为无关联的进程提供共享内存空间，一般也是将一个普通文件映射到内存中。

函数：void *mmap(void *start,size_t length,int prot,int flags,int fd,off_t offsize);
参数start：指向欲映射的内存起始地址，通常设为 NULL，代表让系统自动选定地址，映射成功后返回该地址。
参数length：代表将文件中多大的部分映射到内存。
参数prot：映射区域的保护方式。可以为以下几种方式的组合：
PROT_EXEC 映射区域可被执行
PROT_READ 映射区域可被读取
PROT_WRITE 映射区域可被写入
PROT_NONE 映射区域不能存取
参数flags：影响映射区域的各种特性。在调用mmap()时必须要指定MAP_SHARED 或MAP_PRIVATE。
MAP_FIXED 如果参数start所指的地址无法成功建立映射时，则放弃映射，不对地址做修正。通常不鼓励用此旗标。
MAP_SHARED对映射区域的写入数据会复制回文件内，而且允许其他映射该文件的进程共享。
MAP_PRIVATE 对映射区域的写入操作会产生一个映射文件的复制，即私人的“写入时复制”（copy on write）对此区域作的任何修改都不会写回原来的文件内容。
MAP_ANONYMOUS建立匿名映射。此时会忽略参数fd，不涉及文件，而且映射区域无法和其他进程共享。
MAP_DENYWRITE只允许对映射区域的写入操作，其他对文件直接写入的操作将会被拒绝。
MAP_LOCKED 将映射区域锁定住，这表示该区域不会被置换（swap）。
参数fd：要映射到内存中的文件描述符。如果使用匿名内存映射时，即flags中设置了MAP_ANONYMOUS，fd设为-1。有些系统不支持匿名内存映射，则可以使用fopen打开/dev/zero文件，然后对该文件进行映射，可以同样达到匿名内存映射的效果。
参数offset：文件映射的偏移量，通常设置为0，代表从文件最前方开始对应，offset必须是分页大小的整数倍。
返回值：
若映射成功则返回映射区的内存起始地址，否则返回MAP_FAILED(－1)，错误原因存于errno 中。
错误代码：
EBADF 参数fd 不是有效的文件描述词
EACCES 存取权限有误。如果是MAP_PRIVATE 情况下文件必须可读，使用MAP_SHARED则要有PROT_WRITE以及该文件要能写入。
EINVAL 参数start、length 或offset有一个不合法。
EAGAIN 文件被锁住，或是有太多内存被锁住。
ENOMEM 内存不足。

总结：使用mmap时务必注意以下事项：

1.	创建映射区的过程中，隐含着一次对映射文件的读操作。
2.	当MAP_SHARED时，要求：映射区的权限应 <=文件打开的权限(出于对映射区的保护)。而MAP_PRIVATE则无所谓，因为mmap中的权限是对内存的限制。
3.	映射区的释放与文件关闭无关。只要映射建立成功，文件可以立即关闭。
4.	特别注意，当映射文件大小为0时，不能创建映射区。所以：用于映射的文件必须要有实际大小！！	mmap使用时常常会出现总线错误，通常是由于共享文件存储空间大小引起的。
5.	munmap传入的地址一定是mmap的返回地址。坚决杜绝指针++操作。
6.	如果文件偏移量必须为4K的整数倍
7.	mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。

mmap父子进程通信

父子等有血缘关系的进程之间也可以通过mmap建立的映射区来完成数据通信。但相应的要在创建映射区的时候指定对应的标志位参数flags：

MAP_PRIVATE:  (私有映射)  父子进程各自独占映射区；
	MAP_SHARED:  (共享映射)  父子进程共享映射区；

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
 
int var = 100;  //全局变量
 
int main(void)
{
    int *p;
    pid_t pid;
 
    int fd;
    fd = open("temp", O_RDWR|O_CREAT|O_TRUNC, 0644);
    if(fd < 0){
        perror("open error");
        exit(1);
    }
    unlink("temp");        //删除临时文件目录项，使之具备被释放条件，该文件没有存在的必要，仅用于完成映射区，来用于父子进程间通信，因此unlink。
    ftruncate(fd, 4);
    //p = (int *)mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    p = (int *)mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
    if(p == MAP_FAILED) {                
        perror("mmap error");
        exit(1);
    }
    close(fd);                   //映射区建立完毕,即可关闭文件
 
    pid = fork();                               //创建子进程
    if(pid == 0){
        *p = 2000;
        var = 1000;
        printf("child, *p = %d, var = %d\n", *p, var);
    } else {
        sleep(1);
        printf("parent, *p = %d, var = %d\n", *p, var);
        wait(NULL);
 
        int ret = munmap(p, 4);                 //释放映射区
        if (ret == -1) {
            perror("munmap error");
            exit(1);
        }
    }
 
    return 0;
}

mmap无血缘关系进程间通信

实质上mmap是内核借助文件帮我们创建了一个映射区，多个进程之间利用该映射区完成数据传递。由于内核空间多进程共享，因此无血缘关系的进程间也可以使用mmap来完成通信。只要设置相应的标志位参数flags即可。若想实现共享，当然应该使用MAP_SHARED了。

#include <stdio.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <string.h>
 
struct STU {
    int id;
    char name[20];
    char sex;
};
 
void sys_err(char *str)
{
    perror(str);
    exit(1);
}
 
int main(int argc, char *argv[])
{
    int fd;
    struct STU student = {10, "xiaoming", 'm'};
    struct STU *mm;
 
    if (argc < 2) {
        printf("./a.out file_shared\n");
        exit(-1);
    }
 
    fd = open(argv[1], O_RDWR | O_CREAT, 0664);
    ftruncate(fd, sizeof(student));
 
    mm = mmap(NULL, sizeof(student), PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
    if (mm == MAP_FAILED)
        sys_err("mmap");
 
    close(fd);
 
    while (1) {
        memcpy(mm, &student, sizeof(student));
        student.id++;
        sleep(1);
    }
 
    munmap(mm, sizeof(student));
 
    return 0;
}

#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/mman.h>
#include <string.h>
 
struct STU {
    int id;
    char name[20];
    char sex;
};
 
void sys_err(char *str)
{
    perror(str);
    exit(-1);
}
 
int main(int argc, char *argv[])
{
    int fd;
    struct STU student;
    struct STU *mm;
 
    if (argc < 2) {
        printf("./a.out file_shared\n");
        exit(-1);
    }
 
    fd = open(argv[1], O_RDONLY);
    if (fd == -1)
        sys_err("open error");
 
    mm = mmap(NULL, sizeof(student), PROT_READ, MAP_SHARED, fd, 0);
    if (mm == MAP_FAILED)
        sys_err("mmap error");
    close(fd);
    while (1) {
        printf("id=%d\tname=%s\t%c\n", mm->id, mm->name, mm->sex);
        sleep(2);
    }
    munmap(mm, sizeof(student));
 
return 0;
}

munmap函数

同malloc函数申请内存空间类似的，mmap建立的映射区在使用结束后也应调用类似free的函数来释放。

int munmap(void *addr, size_t length);	成功：0； 失败：-1

匿名映射

使用特殊文件提供匿名内存映射：
适用于具有亲缘关系的进程之间。由于父子进程特殊的亲缘关系，在父进程中先调用mmap()，然后调用 fork()。那么在调用fork()之后，子进程继承父进程匿名映射后的地址空间，同样也继承mmap()返回的地址，这样，父子进程就可以通过映射区 域进行通信了。注意，这里不是一般的继承关系。一般来说，子进程单独维护从父进程继承下来的一些变量。而mmap()返回的地址，却由父子进程共同维护。 对于具有亲缘关系的进程实现共享内存最好的方式应该是采用匿名内存映射的方式。此时，不必指定具体的文件，只要设置相应的标志即可。
另外使用映射区来完成文件读写操作十分方便，父子进程间通信也较容易。但缺陷是，每次创建映射区一定要依赖一个文件才能实现。通常为了建立映射区要open一个temp文件，创建好了再unlink、close掉，比较麻烦。 可以直接使用匿名映射来代替。其实Linux系统给我们提供了创建匿名映射区的方法，无需依赖一个文件即可创建映射区。同样需要借助标志位参数flags来指定。

使用MAP_ANONYMOUS (或MAP_ANON)， 如: 
	int *p = mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0); 
"4"随意举例，该位置表大小，可依实际需要填写。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
 
int var = 100;  //全局变量
 
int main(void)
{
    int *p;
    pid_t pid;
 
   
    p = (int *)mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANON, -1, 0);
    //p = (int *)mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
    if(p == MAP_FAILED) {                
        perror("mmap error");
        exit(1);
    }
    pid = fork();                               //创建子进程
    if(pid == 0){
        *p = 2000;
        var = 1000;
        printf("child, *p = %d, var = %d\n", *p, var);
    } else {
        sleep(1);
        printf("parent, *p = %d, var = %d\n", *p, var);
        wait(NULL);
 
        int ret = munmap(p, 4);                 //释放映射区
        if (ret == -1) {
            perror("munmap error");
            exit(1);
        }
    }
 
    return 0;
}

需注意的是，MAP_ANONYMOUS和MAP_ANON这两个宏是Linux操作系统特有的宏。在类Unix系统中如无该宏定义，可使用如下两步来完成匿名映射区的建立。
②	 fd = open("/dev/zero", O_RDWR);
	② p = mmap(NULL, size, PROT_READ|PROT_WRITE, MMAP_SHARED, fd, 0);

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include<string.h>
#include<sys/types.h>
#include<sys/stat.h>
 
int var = 100;  //全局变量
 
int main(void)
{
    int *p;
pid_t pid;
int fd = open(“/dev/zero”,O_RDWR);

p = (int *)mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_SHARED,fd, 0);
    //p = (int *)mmap(NULL, 4, PROT_READ|PROT_WRITE, MAP_PRIVATE, fd, 0);
    if(p == MAP_FAILED) {                
        perror("mmap error");
        exit(1);
    }
    pid = fork();                               //创建子进程
    if(pid == 0){
        *p = 2000;
        var = 1000;
        printf("child, *p = %d, var = %d\n", *p, var);
    } else {
        sleep(1);
        printf("parent, *p = %d, var = %d\n", *p, var);
        wait(NULL);
 
        int ret = munmap(p, 4);                 //释放映射区
        if (ret == -1) {
            perror("munmap error");
            exit(1);
        }
    }
 
    return 0;
}