【Linux】--进程间通信(一) 管道

【Linux】进程间通信(一) 管道

引言：进程相互之间独立存在，每个进程都有自己的虚拟地址空间，两个进程之间互不了解彼此虚拟地址中的数据内容，此外，两个进程间通信需要借助某些方式，进而可以访问到彼此公共资源，接下来，我们一起来探索一下进程间通信的奥秘！

一、进程间通信的目的

• 1.数据传输：一个进程需要将它的数据发送给另一个进程
• 2.资源共享：多个进程之间共享同样的资源。
• 3.通知事件：一个进程需要向另一个或一组进程发送消息，通知它（它们）发生了某种事件（如进程终止时要通知父进程）。
• 4.进程控制：有些进程希望完全控制另一个进程的执行（如Debug进程），此时控制进程希望能够拦截另一个进程的所有陷入和异常，并能够及时知道它的状态改变

二、进程间通信的分类

管道

• 匿名管道pipe
• 命名管道

System V IPC

• System V 消息队列
• System V 共享内存
• System V 信号量

POSIX IPC

• 消息队列
• 共享内存
• 信号量
• 互斥量
• 条件变量
• 读写锁

三、管道

1.什么是管道

• 管道是Unix中最古老的进程间通信的形式。
• 我们把从一个进程连接到另一个进程的一个数据流称为一个“管道”
  

2.匿名管道

#include <unistd.h>
功能:创建一无名管道
原型
int pipe(int fd[2]);
参数
fd：文件描述符数组,其中fd[0]表示读端, fd[1]表示写端
返回值:成功返回0，失败返回错误代码

实例化代码如下所示：

//例子：从键盘读取数据，写入管道，读取管道，写到屏幕
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
int main( void )
{
int fds[2];
char buf[100];
int len;
if ( pipe(fds) == -1 )
perror("make pipe"),exit(1);
// read from stdin
while ( fgets(buf, 100, stdin) ) {
len = strlen(buf);
// write into pipe
if ( write(fds[1], buf, len) != len ) {
perror("write to pipe");
break;
}
memset(buf, 0x00, sizeof(buf));
// read from pipe
if ( (len=read(fds[0], buf, 100)) == -1 ) {
perror("read from pipe");
break;
}
// write to stdout
if ( write(1, buf, len) != len ) {
perror("write to stdout");
break;
    }
  }
}

用fork来共享管道原理

3.管道读写规则

• 当没有数据可读时

  • O_NONBLOCK disable：read调用阻塞，即进程暂停执行，一直等到有数据来到为止。
  • O_NONBLOCK enable：read调用返回-1，errno值为EAGAIN。

• 当管道满的时候

  • O_NONBLOCK disable： write调用阻塞，直到有进程读走数据
  • O_NONBLOCK enable：调用返回-1，errno值为EAGAIN

• 如果所有管道写端对应的文件描述符被关闭，则read返回0

• 如果所有管道读端对应的文件描述符被关闭，则write操作会产生信号SIGPIPE,进而可能导致write进程退出

• 当要写入的数据量不大于PIPE_BUF时，linux将保证写入的原子性。

• 当要写入的数据量大于PIPE_BUF时，linux将不再保证写入的原子性。

4.管道的特点(重点)

1. 只能用于具有共同祖先的进程（具有亲缘关系的进程）之间进行通信；通常，一个管道由一个进程创建，然后该进程调用fork，此后父、子进程之间就可应用该管道。
2. 管道提供流式服务(可能会发生数据粘连)。
3. 一般而言，进程退出，管道释放，所以管道的生命周期随进程
4. 一般而言，内核会对管道操作进行同步与互斥
5. 管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管道
6. 同步：通过一些条件的判断，来实现对临界条件资源访问的时序合理性
7. 互斥：同一时间只有一个执行流能够操作临界资源，实现对数据的安全操作。
   

5.命名管道

• 管道应用的一个限制就是只能在具有共同祖先（具有亲缘关系）的进程间通信。
• 如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作，它经常被称为命名管道。
• 命名管道是一种特殊类型的文件

6.创建命名管道
命名管道可以从命令行上创建，命令行方法是使用下面这个命令：

$ mkfifo filename

命名管道也可以从程序里创建，相关函数有：

int mkfifo(const char *filename,mode_t mode);

创建命名管道:

int main(int argc, char *argv[])
{
mkfifo("p2", 0644);
return 0;
}

7.匿名管道与命名管道的区别

对 上面两个管道的相同点：

• 1、依赖文件系统，生命周期随进程；
• 2、都是单向通信的；
• 3、按照数据流的方式通信；
• 4、读写之间都是按照同步机制来访问的。

不同点：

• 1、管道只能应用于有血缘关系的进程，命名管道可应用于所有的进程
• 2、管道依赖于文件描述符表，不需要明确的创建文件，命名管道需要明确的创建fifo文件存于文件系统中。

8.命名管道的打开规则

• 如果当前打开操作是为读而打开FIFO时
  • O_NONBLOCK disable：阻塞直到有相应进程为写而打开该FIFO
  • O_NONBLOCK enable：立刻返回成功
• 如果当前打开操作是为写而打开FIFO时
  • O_NONBLOCK disable：阻塞直到有相应进程为读而打开该FIFO
  • O_NONBLOCK enable：立刻返回失败，错误码为ENXIO

9. 举两个命名管道的栗子

• 例子1-用命名管道实现文件拷贝

读取文件，写入命名管道:

//写端
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<fcntl.h>
#include<errno.h>
int main()
{
char *file="./tp";
int ret=mkfifo(file,0664);//创建管道
if(ret<0){
if(errno!=EEXIST){
perror("mkfifo error");
return -1;
}
}
int fd=open(file,O_WRONLY);//将文件以只写方式打开
if(fd<0){
perror("open error");
}
printf("open success\n");

while(1){
char buf[1024]={0};
scanf("%s",buf);
ret=write(fd,buf,strlen(buf));//向fd所引用的文件中写入buf的内容
if(ret<0){
perror("write error");
return -1;
}else if(ret==0){
printf("没人读就关闭");
return 0;
}
}
return 0;
}

读取管道，写入目标文件:

//读端
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<string.h>
#include<fcntl.h>
#include<errno.h>
int main()
{
char *file="./tp";
int ret=mkfifo(file,0664);
if(ret<0){
if(errno!=EEXIST){
perror("mkfifo error");
return -1;
}
}
int fd=open(file,O_RDONLY);
if(fd<0){
perror("open error");
}
printf("open success\n");
while(1){
char buf[1024]={0};
ret=read(fd,buf,1023);//从fd中读取数据放到buf中
if(ret<0){
perror("read error");
return -1;
}else if(ret==0){
printf("没人写就关闭\n");
return 0;
}
printf("buf:[%s]\n",buf);
}
return 0;
}

• 例子2-用命名管道实现server&client通信

# ll
total 12
-rw-r--r--. 1 root root 46 Sep 18 22:37 clientPipe.c
-rw-r--r--. 1 root root 164 Sep 18 22:37 Makefile
-rw-r--r--. 1 root root 46 Sep 18 22:38 serverPipe.c
# cat Makefile
.PHONY:all
all:clientPipe serverPipe
clientPipe:clientPipe.c
gcc -o $@ $^
serverPipe:serverPipe.c
gcc -o $@ $^
.PHONY:clean
clean:
rm -f clientPipe serverPipe

serverPipe.c

 1 #include<stdio.h>
  2 #include<unistd.h>
  3 #include<fcntl.h>
  4 #include<sys/types.h>
  5 #include<sys/stat.h>
  6 #define FIFO "fifo"
  7 
  8 int main()
  9 {
 10     if(mkfifo(FIFO, 0644)<0)
 11     {
 12         perror("mkfifo error");
 13         return 1;
 14     }
 15 
 16     int fd = open(FIFO, O_RDONLY);
 17     if(fd < 0)
 18     {
 19         perror("open error");
 20         return 2;
 21     }
 22 
 23     char buf[1024];
 24     while(1)
 25     {
 26         ssize_t s = read(fd, buf, sizeof(buf)-1);
 27         if(s > 0)
 28         {
 29             buf[s] = 0;
 30             printf("proc_two: %s\n", buf);
 31         }
 32         else if(s==0)
 33         {
 34             printf("proc_two quit, me too...");
 35             break;
 36         }
 37         else
 38         {
 39             break;
 40         }
 41     }
 42     close(fd);
 43     return 0;
 44 }

clientPipe.c

  1 #include<stdio.h>
  2 #include<unistd.h>
  3 #include<sys/types.h>
  4 #include<sys/stat.h>
  5 #include<fcntl.h>
  6 
  7 #define FIFO "fifo"
  8 int main()
  9 {
 10     int fd = open(FIFO, O_WRONLY);
 11     if(fd < 0)
 12     {
 13         perror("open error");
 14         return 1;
 15     }
 16 
 17     char buf[1024];
 18     while(1)
 19     {
 20         printf("eoch# ");
 21         fflush(stdout);
 22         ssize_t s = read(0, buf, sizeof(buf)-1);
 23         if(s>0)
 24         {
 25             buf[s] = 0;
 26             write(fd, buf, strlen(buf));
 27         }
 28     }
 29     close(fd);
 30     return 0;
 31 }

运行结果如下所示：