【进程通信】用命名管道模拟server和client之间的通信

简介: 【进程通信】用命名管道模拟server和client之间的通信

关于命名管道

当了解了匿名管道的通信机制只能用于具有血缘关系的进程之间时,似乎是出于本能的提出疑问–如果两个进程没有任何关系呢?

假如两个进程之间没有血缘关系,彼此进程就没法轻易拥有对方的文件资源,即不能看到同一份共享资源。这时候我们需要除了pipe函数创建管道的另一种方法,可以支持任意两个进程看到同一份共享资源。于是可以考虑使用命名管道。

命名管道是一个特殊的文件。=可以使不相关的进程之间进行通信,创建管道时创建一个名字,以后其它进程就可以通过这个名字来使用这个管道的另一端。这也是为什么我们称这样的管道为命名管道。命名管道是以一个普通的文件形式出现的,包括创建管道、写管道、读管道。值得注意的是,打开普通文件建立内核级缓冲区后,操作系统会及时刷新里面的数据到磁盘文件中,而管道文件(FIFO)的缓冲区则不会。

创建命名管道

使用命令行创建命名管道(FIFO)

使用mkfifo filename指令创建命名管道,其中filename表示文件名。

命名管道文件又叫FIFO文件,其文件类型为p,表示是一个管道文件。

在程序中创建

命名管道也可以在程序中使用mkfifo函数创建。具体使用方式如下:

#include<sys/types.h>
#include<sys/stat.h>
int mkfifo(const char* pathname,mode_t mode);

其中,参数pathname表示的是创建管道文件的路径,如果pathname是相对的,那么会再去进程的环境变量中去找默认路径。mode表示管道文件的权限,即文件最终的权限为mode& ~umask。如果创建成功返回0,否则-1.

当某个进程要使用管道文件时,像普通文件那样,得先打开文件(open),且要确定以什么方式打开(write or read)。

匿名管道和命名管道的区别

  1. 从代码层面上来说,匿名管道是通过pipe函数创建并打开。而命名管道由mkfifo函数创建,打开得用open
  2. 命名管道可以使两个没有关系的进程建立通信,而匿名管道只能用于具有血缘关系的进程之间
  3. 命名管道本质是磁盘上的一个文件

除了创建方式的不同,命名管道和匿名管道具有相同的意义。

命名管道的打开规则

  • 如果当前是以读的方式打开FIFO文件,而此时没有进程以写的方式打开该FIFO文件时,读端进程就会阻塞,直到有进程以写的方式打开该FIFO。
  • 如果当前是以写的方式打开FIFO文件,而此时没有进程以读的方式打开该FIFO文件时,写端进程就会堵塞,直到有进程以读的方式打开该FIFO。

用命名管道实现server和client通信

下面通过命名管道来实现server和client的通信。具体步骤如下:

  1. 将命名管道的操作方法及其属性封装成一个类,方便代码复用
  2. server端创建管道之后接收数据
  3. client端使用管道发送数据
  4. server端回收管道

NamePipe.hpp

用来封装命名管道的操作以及属性

#include <iostream>
#include <string>
#include <cstdio>
#include <sys/stat.h>
#include <sys/types.h>
#include <fcntl.h>
#include <unistd.h>
using namespace std;

const string comm_path = "./myfifo";
#define Creater 1//身份码,1表示创建管道者,2表示使用者
#define User 2
#define Defaultfd -1
#define Read_Mode O_RDONLY
#define Write_Mode O_WRONLY
#define BaseSize 4096//默认读管道的数据大小

class NamePipe
{
private:
  void CreatFifo()
  {
    int res = mkfifo(_fifo_path.c_str(), 0777);
    if (res != 0)
    {
      perror("mkfifo");
    }
  }

  bool OpenNameFifo(int mode)
  {
    _fd = open(_fifo_path.c_str(), mode);
    if (_fd < 0)
      return false;
    return true;
  }

public:
  NamePipe(const string &path, int who)//构造函数,根据身份码来决定谁创建管道
      : _fifo_path(path), _id(who), _fd(Defaultfd)
  {
    if (_id == Creater)
    {
      CreatFifo();//创建管道
      cout << "creat a fifo" << endl;
    }
  }

//读写操作
  bool OpenForWrite()
  {
    return OpenNameFifo(Write_Mode);
  }

  bool OpenForRead()
  {
    return OpenNameFifo(Read_Mode);
  }

  int ReadNamePipe(string &out)
  { // 向管道中读取数据
    char buffer[BaseSize];
    int n = read(_fd, buffer, sizeof(buffer) - 1);
    if (n > 0)
    {
      buffer[n] = '\0';
      out = buffer;
    }
    return n;
  }

  int WriteNamePipe(string in)
  { // 像管道中写数据
    return write(_fd, in.c_str(), in.size());
  }

  ~NamePipe()//析构,删除管道文件,关闭文件
  {
    if (_id == Creater)
    {
      int res = unlink(_fifo_path.c_str()); // 删除管道文件
      if (res != 0)
      {
        perror("unlink");
      }
    }
    if (_fd != Defaultfd)
    { // 关闭文件
      close(_fd);
    }
  }

private:
  int _fd;//FIFO描述fu
  const string _fifo_path;//管道路径
  int _id;//身份码
};

Server.cpp

服务端,读取管道的数据。

#include "NamePipe.hpp"

// Read
int main()
{
    NamePipe fifo(comm_path, Creater);
    // 如果写端没有打开,就会阻塞等待
    cout << "Server 在等待Client打开文件....." << endl;
    sleep(2);
    cout << fifo.OpenForRead() << endl;
    if (fifo.OpenForRead())
    {
        cout << "server 已经打开管道,准备通信" << endl;
        while (true)
        {
            string message = "";
            int n = fifo.ReadNamePipe(message);
            // cout<<message<<endl;
            if (n > 0)
            {
                // 读取成功
                cout << message << endl;
            }
            else if (n == 0)
            {
                // 写端已经关闭,直接退出
                break;
            }
            else
            {
                // 读取失败
                cout << "fifo.ReadNamePipe error" << endl;
                break;
            }
        }
    }
    return 0;
}

client.cpp

客户端,发送数据。

#include "NamePipe.hpp"

// Write
int main()
{
    NamePipe fifo(comm_path, User);
    // 如果读端没有打开,就会阻塞等待
    cout << "Client 在等待Server打开文件....." << endl;
    if (fifo.OpenForWrite())
    {
        cout << "client 已经打开管道,准备通信" << endl;
        while (true)
        {
            string message = "";
            cout << "Please Input: ";
            getline(cin, message);
            fifo.WriteNamePipe(message);
        }
    }
    return 0;
}


相关文章
|
11天前
|
消息中间件 分布式计算 网络协议
从管道路由到共享内存:进程间通信的演变(内附通信方式经典面试题及详解)
进程间通信(Inter-Process Communication, IPC)是计算机科学中的一个重要概念,指的是运行在同一系统或不同系统上的多个进程之间互相发送和接收信息的能力。IPC机制允许进程间共享数据、协调执行流程,是实现分布式系统、多任务操作系统和并发编程的基础。
从管道路由到共享内存:进程间通信的演变(内附通信方式经典面试题及详解)
|
1天前
|
Unix Linux Python
`subprocess`模块是Python中用于生成新进程、连接到它们的输入/输出/错误管道,并获取它们的返回(退出)代码的模块。
`subprocess`模块是Python中用于生成新进程、连接到它们的输入/输出/错误管道,并获取它们的返回(退出)代码的模块。
6 0
|
1天前
|
安全 API Python
`multiprocessing`是Python的一个标准库,用于支持生成进程,并通过管道和队列、信号量、锁和条件变量等同步原语进行进程间通信(IPC)。
`multiprocessing`是Python的一个标准库,用于支持生成进程,并通过管道和队列、信号量、锁和条件变量等同步原语进行进程间通信(IPC)。
5 0
|
3天前
|
安全 Linux 数据格式
【Linux】进程通信----管道通信(下)
【Linux】进程通信----管道通信(下)
14 0
|
3天前
|
Unix Linux
【Linux】进程通信----管道通信(上)
【Linux】进程通信----管道通信(上)
20 0
|
1月前
|
存储 安全 Python
进程通信 , 信号量 , 队列 , 管道 , 共享内存
进程通信 , 信号量 , 队列 , 管道 , 共享内存
|
19天前
|
消息中间件 负载均衡 Linux
【linux】匿名管道|进程池
【linux】匿名管道|进程池
7 0
|
2月前
|
消息中间件 Linux C语言
进程通信:管道与队列
进程通信:管道与队列
|
17天前
|
监控 Linux 应用服务中间件
探索Linux中的`ps`命令:进程监控与分析的利器
探索Linux中的`ps`命令:进程监控与分析的利器