0
点赞
收藏
分享

微信扫一扫

Gradle学习-1

晒大太阳了 2024-06-22 阅读 28

1. 命名管道(FIFO)

1.1. 基本概念

简单,给匿名管道起个名字就变成了命名管道

那么如何给 匿名管道 起名字呢?

  • 结合文件系统,给匿名管道这个纯纯的内存文件分配 inode,将文件名与之构建联系,关键点在于不给它分配 Data block,因为它是一个纯纯的内存文件,是不需要将数据刷盘到磁盘中的

因为没有 Data block,所以命名管道这个特殊文件大小为 0

匿名管道只能用于具有共同祖先的进程(具有亲缘关系的进程)之间的通信,如果要实现两个毫不相关进程之间的通信,可以使用命名管道来做到。

普通文件是很难做到通信的,即便做到通信也无法解决一些安全问题。

1.2.毫不相干的进程之间是怎么通信的

我们来验证一下

 我要完成的目的是在用户端 client 输入数据(从屏幕中读取去),而在客户端 server 接收客户端的数据,然后再从客户端打印出来。

        但是这里需要注意的是,我们要想进行通信,那么就必须可以看到同一份资源,所以这里我就将共同的资源放到了头文件里,然后两个程序就可以看到同一份资源了:

comm.h
  1 #pragma once
  2 #include <stdio.h>
  3 #include <unistd.h>
  4 #include <string.h>
  5 #include <sys/types.h>
  6 #include <sys/stat.h>                                                   
  7 #include <fcntl.h>
  8 
  9 #define FILE_NAME "myfifo"
server.c
  1 #include"comm.h"
  2                                                                         
  3 int main()
  4 {
  5   if(mkfifo(FILE_NAME, 0644) < 0){
  6     perror("myfifo");
  7     return 1;
  8   }
  9 
 10   int fd = open(FILE_NAME, O_RDONLY);
 11   if(fd < 0){
 12     perror("open");
 13     return 2;
 14   }
 15 
 16   char msg[128];
 17   while(1){
 18     msg[0] = 0;
 19     ssize_t s = read(fd, msg, sizeof(msg)- 1);
 20     if(s > 0){
 21       msg[s] = 0;
 22       printf("client# %s\n", msg);
 23     }
 24     else if(s == 0){
 25       printf("client quit!\n");
 26       break;
 27     }
 28     else{
 29       printf("read error!\n");
 30       break;                                                             
 31     }
 32   }
 33   close(fd);
 34 
 35   return 0;
 36 }
 
client.c
  1 #include"comm.h"
  2 
  3 int main()
  4 {
  5   int fd = open(FILE_NAME, O_WRONLY);
  6   if(fd < 0){
  7     perror("open");
  8     return 1;                                                           
  9   }                                                  
 10                                                  
 11   char msg[128];  
 12   while(1){                                   
 13     msg[0] = 0;                      
 14     printf("Please Enter# ");
 15     fflush(stdout);                     
 16     ssize_t s = read(0, msg, sizeof(msg));
 17     if(s > 0){
 18       msg[s] = 0;                                                  
 19       write(fd, msg, strlen(msg));                               
 20     }                                                     
 21   }                                   
 22                                                         
 23   close(fd);                                  
 24   return 0;
 25 }                             

我们可以看到这样的效果。

   而且我们会发现,这两个进程是没有任何关系的,但是它们两个就可以进行通信。而且除了 server 创建一个管道文件,其它的操作和操作普通文件没有区别。

        那么接下来就操作:情况是不是在命名管道开头的那幅图的情况:

        首先先把 server 中读取的操作去掉:

  然后进行下方操作:

我们可以看到,我已经写了好多消息了,但是我们发现 myfifo 的大小一直都是 0 ,换句话说就是我写的消息已经被写到管道的缓冲区里了,但是 server端 并没有读取,所以写的消息还是在内存里,但是又因为 myfifo 的大小为 0 ,就说明数据并没有刷新到磁盘,也就意味着,双方通信依旧是在内存中通信的,和匿名管道的底层原理是一样的,它们采用的都是文件通信。

        所以这下也就更能理解上面的那副图了吧。

1.3.命名管道的工作原理

1.4、命名管道与匿名管道的区别

2.创建命名管道

2.1.mkfifo命令

我们可以使用mkfifo命令来创建命名管道

mkfifo 命名管道的名字

 

 

2.2.mkfifo函数 

 此外我们还可以通过相关的函数来创建,这个函数也叫mkfifo 

​
#include <sys/types.h>
#include <sys/stat.h>

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

path为创建的命名管道的全路径名:
mod为指定了文件的读写权限; 

成功都返回0,失败都返回-1

​

3.命名管道的使用

命名管道和管道的使用方法法基本是相同的。

只是使用命名管道时,必须先调用open()将其打开。因为命名管道是一个存在于硬盘上的文件,而管道是存在于内存中的特殊文件。

需要注意的是,调用open()打开命名管道的进程可能会被阻塞。

  1. 但如果同时用读写方式( O_RDWR)打开,则一定不会导致阻塞;
  2. 如果以只读方式( O_RDONLY)打开,则调用open()函数的进程将会被阻塞直到有写方打开管道;
  3. 同样以写方式( O_WRONLY)打开也会阻塞直到有读方式打开管道。

4.命名管道的四个使用示例 

(1)通过命名管道 ,client & server进行通信

①comm.h中包含一些头文件供client 和 server使用

//comm.h
#pragma once
 
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>
 
#define FILE_NAME "myfifo" //让客户端和服务端使用同一个命名管道

②server.c 代码

实现服务端(server)和客户端(client)之间的通信之前,我们需要先让服务端运行起来,我们需要让服务端运行后创建一个命名管道文件,然后再以读的方式打开该命名管道文件,之后服务端就可以从该命名管道当中读取客户端发来的通信信息了。

#include "comm.h"
 
 
int main()
{
  if(mkfifo(FILE_NAME , 0644) < 0){ //创建管道文件
    perror("mkfifo");
  }
 
 int fd = open(FILE_NAME , O_RDONLY); //只读形式打开
 if(fd < 0){
   perror("open error!\n");
   return 2;
 }
 
 char buf[128];
 while(1){
   ssize_t s = read(fd ,buf, sizeof(buf)-1); //开始读数据
   if(s > 0){
      buf[s] = 0;
      printf("client# %s\n" , buf);
   }
   else if(s == 0){
      printf("client quit!\n");
      break;
   }
   else{
      printf("read error!\n");
      break;
   }
 }
 
 close(fd);
  return 0;
}

③client.c 代码

 而对于客户端来说,因为服务端运行起来后命名管道文件就已经被创建了,所以客户端只需以写的方式打开该命名管道文件,之后客户端就可以将通信信息写入到命名管道文件当中,进而实现和服务端的通信。 

#include "comm.h"
 
 
int main()
{
  int fd = open(FILE_NAME , O_WRONLY); //以写的方式打开文件
  if(fd < 0){
    perror("open error!\n");
    return 1;
  }
 
  char buf[128];
  while(1){
    printf("Please Enter# ");  //提示语句
    fflush(stdout);
    ssize_t s = read(0 , buf , sizeof(buf));  //从键盘中读取数据
   if(s > 0){
     buf[s-1] = 0; //输入时多了一个\n
     write(fd , buf ,strlen(buf)); //把读取到的数据写到管道中
   }
 
  }
 
  return 0;
}

④运行结果

客户端写入的信息进入命名管道当中,服务端再从命名管道当中将信息读取出来打印在服务端的显示器上,该现象说明服务端是能够通过命名管道获取到客户端发来的信息的,换句话说,此时这两个进程之间是能够通信的。

通过ps命令查看这两个进程的信息,可以发现这两个进程确实是两个毫不相关的进程,因为它们的PID和PPID都不相同 

 ⑤client 和 server 谁先退出问题

1) 客户端先退出,服务端将管道当中的数据读完后就再也读不到数据了,那么此时服务端也就会去执行它的其他代码了(在当前代码中是直接退出了)。

2)服务端先退出,客户端写入管道的数据就不会被读取了,也就没有意义了,那么当客户端下一次再向管道写入数据时,就会收到操作系统发来的13号信号(SIGPIPE),此时客户端就被操作系统强制杀掉了。

⑥通信是在内存当中进行的

client端代码不变 ,server端只是以读的方式打开,但是不读取数据  :

 运行程序前后两次查看myfifo管道文件的大小始终为0,说明了双方进程之间的通信依旧是在内存当中进行的,和匿名管道通信是一样的。

(2)通过命名管道,派发计算任务

②client端的代码没有发生变化,只是server端读取数据时对数据进行了一些处理:

#include "comm.h"
 
 
int main()
{
  if(mkfifo(FILE_NAME , 0644) < 0){ //创建管道文件
    perror("mkfifo");
  }
 
 int fd = open(FILE_NAME , O_RDONLY); //只读形式打开
 if(fd < 0){
   perror("open error!\n");
   return 2;
 }
 
 char buf[128];
 while(1){
   ssize_t s = read(fd ,buf, sizeof(buf)-1); //开始读数据
   if(s > 0){
      buf[s] = 0;
 
     //简单计算
     char *p = buf;
     const char *lable="+-*/%";
     int flag = 0; //记录计算的符号,利用下标 
     while(*p){
         switch(*p){
             case '+':
                 flag = 0;
                 break;
             case '-':
                 flag = 1;
                 break;
             case '*':
                 flag = 2;
                 break;
             case '/':
                 flag = 3;
                 break;
             case '%':
                 flag = 4;
                 break;
         }
         p++;
     }
 
     char *data1 = strtok(buf, "+-*/%"); //通过算数符号将左右两个数字分开
     char *data2 = strtok(NULL, "+-*/%");
     int x = atoi(data1); //将字符转整形计算
     int y = atoi(data2);
     int z = 0;
     switch(flag){
         case 0:
             z = x + y;
             break;
         case 1:
             z = x - y;
             break;
         case 2:
             z = x * y;
             break;
         case 3:
             z = x / y;
             break;
         case 4:
             z = x % y;
             break;
     }
 
     printf("%d %c %d = %d\n", x,lable[flag], y, z);
   }
   else if(s == 0){
      printf("client quit!\n");
      break;
   }
   else{
      printf("read error!\n");
      break;
   }
 }
 
 close(fd);
  return 0;
}

③结果

(3)通过命名管道,进行命令操作

     ②client端的代码不变,server端对于输入的数据进行解析,如果有命令则执行:

#include "comm.h"
 
 
int main()
{
  if(mkfifo(FILE_NAME , 0644) < 0){ //创建管道文件
    perror("mkfifo");
  }
 
 int fd = open(FILE_NAME , O_RDONLY); //只读形式打开
 if(fd < 0){
   perror("open error!\n");
   return 2;
 }
 
 char buf[128];
 while(1){
   ssize_t s = read(fd ,buf, sizeof(buf)-1); //开始读数据
   if(s > 0){
      buf[s] = 0;
      printf("client# %s\n" , buf);
 
     //执行命令
      if(fork() == 0){ //child
         execlp(buf , buf ,NULL); //进程替换
         exit(1);
      }
 
      waitpid(-1 , NULL ,0); //进程等待
 
   }
   else if(s == 0){
      printf("client quit!\n");
      break;
   }
   else{
      printf("read error!\n");
      break;
   }
 }
 
 close(fd);
  return 0;
}

(4)通过命名管道,进行文件拷贝

②client端代码 : 以读的方式打开log.txt文件 , 以写的方式打开管道文件 ,将log.txt文件中的数据写到管道中.

#include "comm.h"
 
 
int main()
{
  int fd = open(FILE_NAME, O_WRONLY); //以写的方式打开命名管道文件
	if (fd < 0){
		perror("open");
		return 1;
	}
 
	int fdin = open("log.txt", O_RDONLY); //以读的方式打开log.txt文件
	if (fdin < 0){
		perror("open");
		return 2;
	}
 
	char buf[128];
	while (1){
		//从log.txt文件当中读取数据
		ssize_t s = read(fdin, buf, sizeof(buf));
		if (s > 0){
			write(fd, buf, s); //将读取到的数据写入到命名管道当中
		}
		else if (s == 0){
			printf("read end of file!\n");
			 break;
		}
		else{
			printf("read error!\n");
			break;
		}
	}
 
	close(fd); //通信完毕,关闭命名管道文件
	close(fdin); //数据读取完毕,关闭log.txt文件
	return 0;
}

③server端代码 : 以读的方式打开管道文件(没有管道文件创建) , 以写的方式在本地创建一个log-bat.txt文件,并将管道中的数据写到log-bat.txt文件中。

#include "comm.h"
 
 
int main()
{
  if(mkfifo(FILE_NAME , 0644) < 0){ //创建管道文件
    perror("mkfifo");
  }
 
 int fd = open(FILE_NAME , O_RDONLY); //只读形式打开
 if(fd < 0){
   perror("open error!\n");
   return 2;
 }
 
 int fdout = open("log-bat.txt" , O_WRONLY|O_CREAT , 0644);
 if(fdout < 0){
   perror("open error!\n");
   return 3;
 }
 
 char buf[128];
 while(1){
   ssize_t s = read(fd ,buf, sizeof(buf)-1); //开始读数据
   if(s > 0){
    write(fdout , buf , s); //将数据从管道写入文件
   }
   else if(s == 0){
     printf("client quit!\n");
     break;
   }
   else{
     printf("read error!\n");
     break;
   }
 }
 
  close(fd); //通信关闭,关闭管道文件描述符
  close(fdout); //数据写入完毕
  return 0;
}

⑤进一步理解文件拷贝 

使用管道在本地进行的文件拷贝,所以看似没什么意义,但我们若是将这里的管道想象成“网络”,将客户端想象成“Windows Xshell”,再将服务端想象成“centos服务器”, 那我们此时实现的就是文件上传的功能,若是将方向反过来,那么实现的就是文件下载的功能。

(5). 命名管道和匿名管道的区别

  • 匿名管道由pipe函数创建并打开。
  • 命名管道由mkfifo函数创建,由open函数打开。
  • FIFO(命名管道)与pipe(匿名管道)之间唯一的区别在于它们创建与打开的方式不同,一旦这些工作完成之后,它们具有相同的语义。

5.命令行中的管道理解

(1)使用cat 和 grep 命令 , 利用 管道 “ | ” 对信息进行过滤。

(2)管道“ | ” 是匿名管道还是命名管道 ?

①由于匿名管道只能用于有亲缘关系的进程之间的通信,而命名管道可以用于两个毫不相关的进程之间的通信,因此我们可以先看看命令行当中用管道(“|”)连接起来的各个进程之间是否具有亲缘关系。

②通过管道连接了三个进程,通过ps命令查看这三个进程可以发现,这三个进程的PPID是相同的,也就是说它们是由同一个父进程创建的子进程。

③三个sleep进程的父进程是bash ,三个sleep进程互为兄弟

④结论

若是两个进程之间采用的是命名管道,那么在磁盘上必须有一个对应的命名管道文件名,而实际上我们在使用命令的时候并不存在类似的命名管道文件名,因此命令行上的管道实际上是匿名管道。

举报

相关推荐

0 条评论