1.进程间通信

1.1 IPC方法

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

在进程间完成数据传递需要借助操作系统提供特殊的方法，如：文件、管道、信号、共享内存、消息队列、套接字、命名管道等。随着计算机的蓬勃发展，一些方法由于自身设计缺陷被淘汰或者弃用。现今常用的进程间通信方式有：

① 管道 (使用最简单)

② 信号 (开销最小)

③ 共享映射区 (无血缘关系)

④ 本地套接字 (最稳定)

1.2 管道

1.2.1 管道的概念

管道是一种最基本的IPC机制，作用于有血缘关系的进程之间，完成数据传递。调用pipe系统函数即可创建一个管道。有如下特质：

其本质是一个伪文件(实为内核缓冲区)

由两个文件描述符引用，一个表示读端，一个表示写端。

规定数据从管道的写端流入管道，从读端流出。

管道的原理: 管道实为内核使用环形队列机制，借助内核缓冲区(4k)实现。

管道的局限性：

① 数据不能进程自己写，自己读。

② 管道中数据不可反复读取。一旦读走，管道中不再存在。

③采用半双工通信方式，数据只能在单方向上流动。

④ 只能在有公共祖先的进程间使用管道。

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

1.2.2 pipe函数

创建管道

************************************
    int pipe(int pipefd[2]);  
    成功：0；
    失败：-1，设置errno
***********************************
函数调用成功返回r/w两个文件描述符。
无需open，但需手动close。
**********************************
规定：
fd[0] → r； 
fd[1] → w，就像0对应标准输入，1对应标准输出一样。
***********************************
向管道文件读写数据其实是在读写内核缓冲区。

管道创建成功以后，创建该管道的进程（父进程）同时掌握着管道的读端和写端。如何实现父子进程间通信呢？通常可以采用如下步骤：

父进程调用pipe函数创建管道，得到两个文件描述符fd[0]、fd[1]指向管道的读端和写端。

父进程调用fork创建子进程，那么子进程也有两个文件描述符指向同一管道。

父进程关闭管道读端，子进程关闭管道写端。父进程可以向管道中写入数据，子进程将管道中的数据读出。由于管道是利用环形队列实现的，数据从写端流入管道，从读端流出，这样就实现了进程间通信。

练习：父子进程使用管道通信，父写入字符串，子进程读出并，打印到屏幕。      
【pipe.c】
1
2
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
void sys_err(const char *str){
        perror(str);
        exit(1);
}
int main(int argc,char *argv[])
{
        int ret;
        int fd[2];
        pid_t pid;
        char *str = "hello pipe\n";
        char buf[1024];
        ret =pipe(fd);
        if(ret == -1){
                sys_err("pipe error");
        }
        pid=fork();
        if(pid > 0){
                close(fd[0]);
                write(fd[1],str,strlen(str));
                close(fd[1]);
        }else if(pid==0){
                close(fd[1]);
                ret=read(fd[0],buf,sizeof(buf));
                write(STDOUT_FILENO,buf,ret);
                close(fd[0]); }
        return 0;
}

思考：为甚么，程序中没有使用sleep函数，但依然能保证子进程运行时一定会读到数据呢？

1.2.3 管道的读写行为

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

如果所有指向管道写端的文件描述符都关闭了（管道写端引用计数为0），而仍然有进程从管道的读端读数据，那么管道中剩余的数据都被读取后，再次read会返回0，就像读到文件末尾一样。

如果有指向管道写端的文件描述符没关闭（管道写端引用计数大于0），而持有管道写端的进程也没有向管道中写数据，这时有进程从管道读端读数据，那么管道中剩余的数据都被读取后，再次read会阻塞，直到管道中有数据可读了才读取数据并返回。

如果所有指向管道读端的文件描述符都关闭了（管道读端引用计数为0），这时有进程向管道的写端write，那么该进程会收到信号SIGPIPE，通常会导致进程异常终止。当然也可以对SIGPIPE信号实施捕捉，不终止进程。具体方法信号章节详细介绍。

如果有指向管道读端的文件描述符没关闭（管道读端引用计数大于0），而持有管道读端的进程也没有从管道中读数据，这时有进程向管道写端写数据，那么在管道被写满时再次write会阻塞，直到管道中有空位置了才写入数据并返回。

总结：

① 读管道：

管道中有数据，read返回实际读到的字节数。

管道中无数据：

(1) 管道写端被全部关闭，read返回0 (好像读到文件结尾)

(2) 写端没有全部被关闭，read阻塞等待(不久的将来可能有数据递达，此时会让出cpu)

② 写管道：

管道读端全部被关闭，进程异常终止(也可使用捕捉SIGPIPE信号，使进程不终止)

管道读端没有全部关闭：

(1) 管道已满，write阻塞。

(2) 管道未满，write将数据写入，并返回实际写入的字节数。

练习：使用管道实现父子进程间通信，完成：ls | wc –l。假定父进程实现ls，子进程实现wc。
ls命令正常会将结果集写出到stdout，但现在会写入管道的写端；wc –l 正常应该从stdin读取数据，但此时会从管道的读端读。
【pipe1.c】
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
void sys_err(const char *str){
        perror(str);
        exit(1);
}
int main(int argc,char *argv[])
{
        int fd[2];
        int ret;
        pid_t pid;
        ret = pipe(fd);
        if(ret == -1){
                sys_err("pipe error ");
        }
        pid = fork();
        if(pid == -1){
                sys_err("fork error");
        }else if(pid > 0){
                close(fd[0]);
                dup2(fd[1],STDOUT_FILENO);
                execlp("ls","ls",NULL);
        }else if(pid == 0){
                close(fd[1]);
                dup2(fd[0],STDIN_FILENO);
                execlp("wc","wc","-l",NULL);
        }
        return 0;
}
~    
程序执行，发现程序执行结束，shell还在阻塞等待用户输入。
这是因为，shell → fork → ./pipe1， 
程序pipe1的子进程将stdin重定向给管道，
父进程执行的ls会将结果集通过管道写给子进程。
若父进程在子进程打印wc的结果到屏幕之前被shell调用wait回收，
shell就会先输出$提示符。

练习：使用管道实现兄弟进程间通信。兄：ls 弟： wc -l 父：等待回收子进程。

要求，使用“循环创建N个子进程”模型创建兄弟进程，使用循环因子i标示。

注意管道读写行为。

【pipe2.c】
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <sys/wait.h>
void sys_err(const char *str){
        perror(str);
        exit(1);
}
int main(int argc,char *argv[])
{
        int fd[2];
        int ret,i;
        pid_t pid;
        ret = pipe(fd);
        if(ret == -1){
                sys_err("pipe error ");
        }
  for(i=0;i<2;i++){
  pid=fork();
  if(pid == -1){
    sys_err("fork error");
  }
  if(pid==0)
  break;
}
  if(i==2){
  close(fd[0]);
  close(fd[1]);
  wait(NULL);
  wait(NULL);
  }else if(i == 0){
  close(fd[0]);
  dup2(fd[1],STDOUT_FILENO);
  execlp("ls","ls",NULL);
  sys_err("execlp ls error");
  }else if(i = 1){
  close(fd[1]);
  dup2(fd[0],STDIN_FILENO);
  execlp("wc","wc","-l",NULL);
  sys_err("execlp wc error");
  }
        return 0;
}

测试：是否允许，一个pipe有一个写端，多个读端呢？

是否允许有一个读端多个写端呢？

【pipe3.c】
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <sys/wait.h>
void sys_err(const char *str){
        perror(str);
        exit(1);
}
int main(void)
{
        pid_t pid;
        int fd[2],i,n;
        char buf[1024];
        int ret = pipe(fd);
        if(ret == -1){
                sys_err("pipe error ");
        }
  for(i=0;i<2;i++){
  if((pid=fork())==0)
    break;
  else if(pid == -1){
    perror("pipe error");
    exit(1);
  }
  }
  if(i==0){
  close(fd[0]);
  write(fd[1],"1.hello\n",strlen("1.hello\n"));
  }else if(i == 1){
  close(fd[0]);
  write(fd[1],"2.world\n",strlen("2.world\n"));
  }else{
  close(fd[1]);
  sleep(1);
  n = read(fd[0],buf,1024);
  write(STDOUT_FILENO,buf,n);
  for(i=0;i<2;i++)
    wait(NULL);
  }
        return 0;
}

1.2.4 管道缓冲区大小

可以使用ulimit –a 命令来查看当前系统中创建管道文件所对应的内核缓冲区大小。通常为：

pipe size            (512 bytes, -p) 8

也可以使用fpathconf函数，借助参数选项来查看。使用该宏应引入头文件

long fpathconf(int fd, int name); 
成功：返回管道的大小  
失败：-1，设置errno

1.2.5 管道的优劣

优点：简单，相比信号，套接字实现进程间通信，简单很多。

缺点：

只能单向通信，双向通信需建立两个管道。

只能用于父子、兄弟进程(有共同祖先)间通信。该问题后来使用fifo有名管道解决。

1.3 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等。

=======创建fifo：=======
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <pthread.h>
#include <sys/stat.h>
void sys_err(const char *str)
{
  perror(str);
  exit(1);
}
int main(int argc,char *argv[])
{
  int ret = mkfifo("mytestfifo",0664);
  if(ret == -1)
  sys_err("mkfifo error");
  return 0;
}
=======读fifo：=======
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
void sys_err(char *str)
{
        perror(str);
        exit(1);
}
int main(int argc,char *argv[])
{
        int fd,len;
        char buf[4096];
        if(argc < 2){
                printf("Enter like this :./a.out fifoname\n");
                return -1;
        }
        fd = open(argv[1],O_RDONLY);
        if(fd < 0){
                sys_err("open");
        }
        while(1){
                len = read(fd,buf,sizeof(buf));
                write(STDOUT_FILENO,buf,strlen(buf));
                sleep(1);
        }
        close(fd);
        return 0;
}
=======写fifo：=======
#include <stdio.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
void sys_err(char *str)
{
  perror(str);
  exit(1);
}
int main(int argc,char *argv[])
{
  int fd,i;
  char buf[4096];
  if(argc < 2){
  printf("Enter like this :./a.out fifoname\n");
  return -1;
  }
  fd = open(argv[1],O_WRONLY);
  if(fd < 0){
  sys_err("open");
  }
  i = 0;
  while(1){
  sprintf(buf,"hello itcast %d\n",i++);
  write(fd,buf,strlen(buf));
  sleep(1);
  }
  close(fd);
  return 0;
}

1.4 共享存储映射

1.4.1 文件进程间通信

使用文件也可以完成IPC，理论依据是，fork后，父子进程共享文件描述符。也就共享打开的文件。

练习：编程测试，父子进程共享打开的文件。借助文件进行进程间通信。

【fork_shared_fd.c】
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <fcntl.h>
#include <sys/wait.h>
int main(void)
{
  int fd1,fd2;
  pid_t pid;
  char *str="--------test for shared fd in parent child process---------";
  char buf[4096]; 
  pid = fork();
  if(pid < 0){
  perror("fork error");
  exit(1);
  }else if(pid == 0){
  fd1 = open("test.txt",O_RDWR);
  if(fd1<0){
  perror("open error");
  exit(1);
  }
  write(fd1,str,strlen(str));
  printf("child wrote over...\n");
  }else{
  fd2=open("test.txt",O_RDWR);
  if(fd2 < 0){
    perror("open error");
    exit(1);
  }
  sleep(1);
  int len =read(fd2,buf,sizeof(buf));
  write(STDOUT_FILENO,buf,len);
  wait(NULL);
  }
  return 0;
}

思考，无血缘关系的进程可以打开同一个文件进行通信吗？为什么？

无血缘关系，用文件进行通信

===========test1.c===================
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#define N 5
int main(void)
{
  char buf[1024];
  char *str="---------secesuss---------------\n";
  int ret;
  int fd = open("test.txt",O_RDWR|O_TRUNC|O_CREAT,0064);
  write(fd,str,strlen(str));
  printf("test1 write into test.txt finish\n");
  sleep(N);
  lseek(fd,0,SEEK_SET);
  ret =read(fd,buf,sizeof(buf));
  ret =write(STDOUT_FILENO,buf,ret);
  if(ret == -1){
  perror("write second error");
  exit(1);
  }
  close(fd);
  return 0;
}
===========test2.c===================
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
int main(void){
  char buf[1024];
  char *str="-----------------test2 write secesuss--------------------\n";
  int ret;
  sleep(2);
  int fd = open("test.txt",O_RDWR);
  ret =read(fd,buf,sizeof(buf));
  write(STDOUT_FILENO,buf,ret);
  write(fd,str,strlen(str));
  printf("test2 read/write finish\n");
  close(fd);
  return 0;
}

1.4.2 存储映射I/O

存储映射I/O (Memory-mapped I/O)使一个磁盘文件与存储空间中的一个缓冲区相映射。于是当从缓冲区中取数据，就相当于读文件中的相应字节。于此类似，将数据存入缓冲区，则相应的字节就自动写入文件。这样，就可在不适用read和write函数的情况下，使用地址（指针）完成I/O操作。

使用这种方法，首先应通知内核，将一个指定文件映射到存储区域中。这个映射工作可以通过mmap函数来实现。

1.4.2.1 mmap函数

void *mmap(void *adrr, size_t length, int prot, int flags, int fd, off_t offset); 
返回：
成功：返回创建的映射区首地址；
失败：MAP_FAILED ，error
参数： 
  addr:  建立映射区的首地址，由Linux内核指定。使用时，直接传递NULL
  length： 欲创建映射区的大小
  prot： 映射区权限PROT_READ、PROT_WRITE、PROT_READ|PROT_WRITE
  flags：  标志位参数(常用于设定更新物理区域、设置共享、创建匿名映射区)
      MAP_SHARED:  会将映射区所做的操作反映到物理设备（磁盘）上。
      MAP_PRIVATE: 映射区所做的修改不会反映到物理设备。
  fd：  用来建立映射区的文件的描述符
  offset：  映射文件的偏移(4k的整数倍)

1.4.2.2 munmap函数

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

int munmap(void *addr, size_t length);  成功：0； 失败：-1
测试mmap.munmap函数的代码
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <sys/mman.h>
void sys_err(const char *str)
{
  perror(str);
  exit(1);
}
int main(int argc ,char *argv[])
{
  char *p =NULL;
  int fd;
  fd  = open("testmap",O_RDWR|O_CREAT|O_TRUNC,0664);
  if(fd == -1)
  sys_err("open error");
  lseek(fd,10,SEEK_END);
  write(fd,"\0",1);
  //ftruncate(fd,10);
  int len =lseek(fd,0,SEEK_END);
  p=mmap(NULL,len,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
  if(p == MAP_FAILED){
  sys_err("mmap error");
  }
  //
  strcpy(p,"hello mmap");
  printf("-----------%s\n",p);
  int ret = munmap(p,len);
  if(ret == -1){
  sys_err("munmap error");
  }
  return 0;
}

1.4.2.3 mmap函数

思考：
1. 可以open的时候O_CREAT一个新文件来创建映射区吗?
用于创建映射区的文件大小为0，实际指定非0大小创建映射区域，出总线错误。
用于创建映射区的文件大小为0，实际指定0大小创建映射区，出无效参数。
============================================================================================================================
2. 如果open时O_RDONLY，mmap时PROT参数指定PROT_READ|PROT_WRITE会怎样？
用于创建映射区的文件读写属性为只读，映射区域属性为读写，出无效参数。
创建映射区，需要read权限。mmap的读写权限，应该<=文件的open权限，mmap只写不行。
============================================================================================================================
3. 文件描述符先关闭，对mmap映射有没有影响？
文件描述符fd,在mmap创建映射区完成就可以关闭。后续访问文件，用地址访问。
============================================================================================================================
4. 如果文件偏移量为1000会怎样？
offset必须要是4096的整数倍。（MMU映射的最小单元4k）
============================================================================================================================
5. 对mem越界操作会怎样？
对申请的内存，不能越界访问
============================================================================================================================
6. 如果mem++，munmap可否成功？
munmap传入的地址一定是mmap的返回地址。坚决杜绝指针++操作。
============================================================================================================================
7. mmap什么情况下会调用失败？
一共6个参数，所有的参数都有失败的可能性
============================================================================================================================
8. 如果不检测mmap的返回值，会怎样？
出现错误的地方很多，你会不知道错误在那。
============================================================================================================================
总结：
使用mmap时务必注意以下事项：
1.创建映射区的过程中，隐含着一次对映射文件的读操作。
2.当MAP_SHARED时，要求：映射区的权限应 <= 文件打开的权限(出于对映射区的保护)。而MAP_PRIVATE则无所谓，因为mmap中的权限是对内存的限制。
映射区访问权限为“私有”MAP_PRIVATE,对内存所做的所有修改，只在内存有效，不会反映到物理磁盘上。
3.映射区的释放与文件关闭无关。只要映射建立成功，文件可以立即关闭。
4.特别注意，当映射文件大小为0时，不能创建映射区。所以：用于映射的文件必须要有实际大小！！  mmap使用时常常会出现总线错误，通常是由于共享文件存储空间大小引起的。如，400字节大小的文件，在建立映射区时offset 4096字节，则会报出总线错。
5.munmap传入的地址一定是mmap的返回地址。坚决杜绝指针++操作。
6.如果文件偏移量必须为4K的整数倍
7.mmap创建映射区出错概率非常高，一定要检查返回值，确保映射区建立成功再进行后续操作。
============================================================================================================================
mmap函数的保险调用方式：
1.fd=open("文件名"，O_RDWR)；
2.mmap(NULL,有效文件大小，PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);

1.4.3 mmap父子进程通信

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

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

练习：父进程创建映射区，然后fork子进程，子进程修改映射区内容，而后，父进程读取映射区内容，查验是否共享。

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <sys/mman.h>
int var = 100;
int main(){
  int *p;
  pid_t pid;
  int fd;
  fd= open("temp",O_RDWR|O_CREAT|O_TRUNC,0664);
  if(fd<0){
  perror("open error");
  exit(1);
  }
  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\n,var=%d\n",*p,var);
  wait(NULL);
  int ret =munmap(p,4);
  if(ret == -1){
  perror("munmap error");
  exit(1);
  }
  }
  return 0;
  }

结论：父子进程共享：

打开的文件

mmap建立的映射区(但必须要使用MAP_SHARED)

1.4.4 匿名映射

通过使用我们发现，使用映射区来完成文件读写操作十分方便，父子进程间通信也较容易。但缺陷是，每次创建映射区一定要依赖一个文件才能实现。通常为了建立映射区要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/wait.h>
#include <sys/mman.h>
int var = 100;
int main(void){
  int *p;
  pid_t pid;
  //p=(int *)mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
  p=(int *)mmap(NULL,40,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANONYMOUS,-1,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\n,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);

1.4.5 mmap无血缘关系进程间通信

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

值得注意的是：MAP_ANON和 /dev/zero 都不能应用于非血缘关系进程间通信。只能用于亲子进程间。
【mmap_w.c】
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
struct student{
  int id;
  char name[256];
  int age;
};
void sys_err(const char *str)
{
  perror(str);
  exit(1);
}
int main(int argc,char *argv[]){
  struct student *p;
  struct student stu={10,"xiaoming",18};
  int fd;
  fd = open("test_map",O_RDWR|O_CREAT|O_TRUNC,0664);
  if(fd == -1){
  sys_err("open error");
  }
  ftruncate(fd,sizeof(stu));
  p=mmap(NULL,sizeof(stu),PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
  if(p == MAP_FAILED){
    perror("mmap error");
    exit(1);
  }
  close(fd);
  while(1){
  memcpy(p,&stu,sizeof(stu));
  }
  int ret =munmap(p,sizeof(stu));
  if(ret == -1){
  perror("munmap error");
  exit(1);
  }
  return 0;
  }
【mmap_r.c】
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <sys/mman.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
struct student{
  int id;
  char name[256];
  int age;
};
void sys_err(const char *str)
{
  perror(str);
  exit(1);
}
int main(int argc,char *argv[]){
  struct student *p;
  //pid_t pid;
  struct student stu;
  int fd;
  fd = open("test_map",O_RDONLY);
  if(fd == -1){
  sys_err("open error");
  }
  p=mmap(NULL,sizeof(stu),PROT_READ,MAP_SHARED,fd,0);
  if(p == MAP_FAILED){
    perror("mmap error");
    exit(1);
  }
  close(fd);
  while(1){
  printf("id = %d,name= %s,age=%d\n",p->id,p->name,p->age);
  sleep(1);
  }
  int ret =munmap(p,sizeof(stu));
  if(ret == -1){
  perror("munmap error");
  exit(1);
  }
  return 0;
  }

linux系统编程（八）进程间通信

1.进程间通信

1.1 IPC方法

1.2 管道

1.2.1 管道的概念

1.2.2 pipe函数

1.2.3 管道的读写行为

1.2.4 管道缓冲区大小

1.2.5 管道的优劣

1.3 FIFO

1.4 共享存储映射

1.4.1 文件进程间通信

1.4.2 存储映射I/O

1.4.2.1 mmap函数

1.4.2.2 munmap函数

1.4.2.3 mmap函数

1.4.3 mmap父子进程通信

1.4.4 匿名映射

1.4.5 mmap无血缘关系进程间通信

热门文章

最新文章

相关课程

相关电子书

推荐镜像

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

linux系统编程（八）进程间通信

1.进程间通信

1.1 IPC方法

1.2 管道

1.2.1 管道的概念

1.2.2 pipe函数

1.2.3 管道的读写行为

1.2.4 管道缓冲区大小

1.2.5 管道的优劣

1.3 FIFO

1.4 共享存储映射

1.4.1 文件进程间通信

1.4.2 存储映射I/O

1.4.2.1 mmap函数

1.4.2.2 munmap函数

1.4.2.3 mmap函数

1.4.3 mmap父子进程通信

1.4.4 匿名映射

1.4.5 mmap无血缘关系进程间通信

热门文章

最新文章

相关课程

相关电子书

推荐镜像