1. 进程间通信的概念
进程间通信是指不同的进程之间进行信息的传递
1. 同一主机上的进程通信
父子进程之间
非父子进程之间
2.不同主机上的进程通信(网络通信)
2. 普通文件通信
父子进程之间可以直接通过文件描述符号(fd)直接进行通信
**进程之间通过文件通信的模型:** 示例: 父进程写文件,子进程读取文件
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
//父进程写文件 子进程读文件
int main(){
int fd = open("a.dat",O_RDWR | O_CREAT,0666);
if(-1 == fd){
printf("文件创建失败:%m\n"),exit(-1);
}else{
printf("文件创建成功!\n");
}
close(fd);
if(fork()){
//父进程写文件
int n = 0;
while(1){
int fd = open("a.dat",O_WRONLY);
if(-1 == fd)
printf("父: 文件打开失败:%m\n"),exit(-1);
else
printf("父: 文件打开成功!\n");
write(fd,&n,4);
close(fd);
sleep(1);
n+=2;
}
}else{
//子进程读文件
int m;
while(1){
int fd = open("a.dat",O_RDONLY);
if(-1 == fd)
printf("子: 文件打开失败:%m\n"),exit(-1);
else
printf("子: 文件打开成功!\n");
sleep(1);
read(fd,&m,4);
printf(">> %d\n",m);
close(fd);
}
}
return 0;
}
运行结果:
- 非父子进程之间就只能通过具体的文件来进行通信
3. 文件映射虚拟内存通信
经常用于父子进程之间的通信
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/mman.h>
//子进程控制父进程循环的暂停与否(通过文件映射虚拟内存的方式实现)
int main(){
//1. 打开文件
int fd = open("mmap.dat",O_CREAT|O_RDWR,0666);
if(-1 == fd) printf("文件创建失败:%m\n"),exit(-1);
printf("文件创建成功!\n");
//2. 修改文件大小
ftruncate(fd,4);
//3. 关联映射
int* p = (int*)mmap(NULL,4,PROT_READ|PROT_WRITE,MAP_SHARED,fd,0);
if((int*)-1 == p) printf("mmap fail:%m\n"),exit(-1),close(fd);
printf("mmap sucess!\n");
*p = 0;
//4. 使用映射
if(fork()){
//父进程
int n = 0;
while(1){
while(*p);
printf("父进程 >> *p == %d\n",*p);
printf("父进程 >> %d\n",++n);
sleep(1);
}
}else{
//子进程
char ch;
int n = 0;
while(1){
read(0,&ch,1);
if(ch == ' ')
n++;
if(n%2 == 1)
*p = 1; //暂停
else
*p = 0; //继续
printf("子进程: n: %d *p (%d) 空格被按下!\n",n,*p);
}
}
//5.卸载映射
munmap(p,4);
//6.关闭文件
close(fd);
return 0;
}
运行结果:
4. 管道通信(first in first out FIFO)
4.1 父子进程之间
父子进程之间通过**匿名管道**进行通信
使用**匿名管道**进行通信的步骤:
1. 创建文件描述符号 **int fds\[2\];**
2. 将文件描述符号(fd)变成管道 **pipe**
3. 使用管道
4. 关闭文件描述符(**fd**)
示例:
使用匿名管道 父进程循环等待用户输入并写入管道 子进程循环读取管道内容并输出
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
//使用匿名管道 父进程循环等待用户输入并写入管道 子进程循环读取管道内容并输出
int main(){
//1. 创建文件描述符号 int fds[2]; fds[0] 读 fds[1] 写
int fds[2];
//2. 将文件描述符号(fd)变成管道 pipe
int ret = pipe(fds);
if(-1 == ret) printf("创建管道失败:%m\n"),exit(-1);
printf("创建管道成功!\n");
//3. 使用管道
if(fork()){
char wbuff[1024] = {0};
while(1){
scanf("%s",wbuff);
write(fds[1],wbuff,strlen(wbuff));
sleep(1);
}
}else{
char rbuff[1024] = {0};
while(1){
sleep(1);
int r = read(fds[0],rbuff,1023);
if(r > 0){
rbuff[r]=0;
printf(">> %s\n",rbuff);
}
}
}
//4. 关闭文件描述符(fd)
close(fds[0]);
close(fds[1]);
return 0;
}
运行结果:
4.2 非父子进程之间
非父子进程之间通过**有名管道**进行通信
使用**有名管道**进行通信的步骤:
文件A 文件B
1\. 创建管道文件 mkfifo
2. 打开管道文件 2. 打开管道文件
3. 向管道文件写入数据 3\. 从管道文件读取数据
4. 关闭管道 4. 关闭管道
5. 删除管道文件 unlink
文件A:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
//文件A 数据写入端
int main(){
//1.创建管道文件
int ret = mkfifo("test.pipe",0666);
if(-1 == ret) printf("创建管道文件失败:%m\n"),exit(-1);
printf("创建管道文件成功!\n");
//2.打开管道文件
int fd = open("test.pipe",O_WRONLY,0666);
if(-1 == fd) printf("打开管道文件失败:%m\n"),unlink("test.pipe"),exit(-1);
printf("打开管道文件成功!\n");
//3.向管道文件中写入数据
int n = 0;
char buff[1024] = {0};
while(1){
sprintf(buff,"Linux,学了忘得好快!%d",++n);
write(fd,buff,strlen(buff));
sleep(1);
}
//4.关闭管道
close(fd);
//5.删除管道文件
unlink("test.pipe");
return 0;
}
文件B:
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
//文件B 数据读取端
int main(){
//2. 打开管道文件
int fd = open("test.pipe",O_RDONLY,0666);
if(-1 == fd) printf("文件打开失败:%m\n"),unlink("test.pipe"),exit(-1);
printf("文件打开成功!\n");
//3. 从管道文件中读取数据
int r = 0;
char buff[1024]={0};
while(1){
r = read(fd,buff,1023);
if(r > 0){
buff[r] = 0;
printf(">> %s\n",buff);
}
}
//4. 关闭管道
close(fd);
return 0;
}
运行结果:
注:
1. 在**共享文件夹**之中**不能创建管道文件** 
2. 打开管道文件的时候只有**两边一起打开**才会返回,只有一边打开会阻塞
3. **先关闭读取端,会导致写入端进程结束** 
4.**先关闭写入端,读取端进程进入阻塞状态** 
5. 关于标准输入设备(0)与标准输出设备(1)的使用
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <unistd.h>
int main(){
char buff[1024];
int r;
while(1){
//使用标准输入设备输入
//输入,向内存中输入,等于从文件读取到内存因此为read
r = read(0,buff,1023);
if(r > 0){
buff[r] = 0;
//使用标准输出设备输出
//输出,从内存中输出,等于从内存写到文件因此为write
write(1,buff,r);
printf("\n");
}
}
return 0;
}
运行结果:
