✨个人主页：北 海
🎉所属专栏：Linux学习之旅
🎃操作环境：CentOS 7.6 阿里云远程服务器
文章目录
🌇前言🏙️正文1、什么是命名管道1.1、创建及简单使用1.2、命名管道的工作原理1.3、命名管道与匿名管道的区别 2、命名管道的特点及特殊场景2.1、特点2.2、四种特殊场景 3、命名管道实操3.1、实现文件拷贝3.2、实现进程控制3.3、实现进程遥控（配合简易版 bash）3.4、实现字符实时读取 🌆总结🌇前言
命名管道通信属于IPC的其中一种方式，作为管道家族，命名管道的特点就是自带同步与互斥机制、数据单向流通，与匿名管道不同的是：命名管道有自己的名字，因此可以被没有血缘关系的进程看到，意味着命名管道可以实现毫不相干的两个独立进程间通信
🏙️正文
1、什么是命名管道
简单，给匿名管道起个名字就变成了命名管道
那么如何给匿名管道起名字呢？
结合文件系统，给匿名管道这个纯纯的内存文件分配inode，将文件名与之构建联系，关键点在于不给它分配Data block，因为它是一个纯纯的内存文件，是不需要将数据刷盘到磁盘中的
可以将命名管道理解为 “挂名” 后的匿名管道，把匿名管道加入文件系统中，但仅仅是挂个名而已，目的就是为了让其他进程也能看到这个文件（文件系统中的文件可以被所有进程看到）
因为没有 Data block，所以命名管道这个特殊文件大小为 0
1.1、创建及简单使用
命令管道的创建依赖于函数mkfifo，函数原型如下
#include <sys/types.h>#include <sys/stat.h>int mkfifo(const char *pathname, mode_t mode);
关于mkfifo函数
对于参数1，既可以传递绝对路径/home/xxx/namePipeCode/fifo，也可以传递相对路径./fifo，当然绝对路径更灵活，但也更长
对于参数2，mode_t其实就是对unsigned int的封装，等价于uint32_t，而mode就是创建命名管道时的初始权限，实际权限需要经过umask掩码计算
不难发现，mkfifo和mkdir非常像，其实mkfifo可以直接在命令行中运行
创建一个名为fifo的命名管道文件
mkfifo fifo
成功解锁了一种新的特殊类型文件：p管道文件
出自：Linux 权限理解和学习
这个管道文件也非常特殊：大小为 0，从侧面说明管道文件就是一个纯纯的内存级文件，有自己的上限，出现在文件系统中，只是单纯挂个名而已
可以直接在命令行中使用命名管道：
echo可以进行数据写入，可以重定向至fifocat可以进行数据读取，同样也可以重定向于fifo打开两个终端窗口（两个进程），即可进行通信
当然也可以通过程序实现两个独立进程IPC
思路：创建 服务端server和 客户端client两个独立的进程，服务端server创建并以读的方式打开管道文件，客户端client以写的方式打开管道文件，打开后俩进程可以进程通信，通信结束后，由客户端关闭写端（服务端读端读取到0后也关闭并删除命令管道文件）
注意：
当管道文件不存在时，文件会打开失败，因此为了确保正常通信，需要先运行服务端server创建管道文件服务端启动后，因为是读端，所以会阻塞等待 客户端（写端）写入数据客户端写入数据时，因为'\n'也被读取了，所以要去除此字符通信结束后，需要服务端主动删除管道文件
unlink 命令管道文件名//删除管道文件
为了让服务端和客户端能享有同一个文件名，可以创建一个公共头文件common.h，其中存储 命名管道文件名及默认权限等公有信息
公共资源
common.h
#pragma once#include <iostream>#include <string>std::string fifo_name = "./fifo"; //管道名uint32_t mode = 0666; //权限
服务端
#include <iostream>#include <cstring>#include <cerrno>#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include "common.h"using namespace std;int main(){// 服务端// 1、创建命名管道文件int ret = mkfifo(fifo_name.c_str(), mode);if (ret < 0){cerr << "mkfifo fail! errno: " << errno << " | " << strerror(errno) << endl;exit(0);}// 2、以读的方式打开文件int rfd = open(fifo_name.c_str(), O_RDONLY);if (rfd < 0){cerr << "open fail! errno: " << errno << " | " << strerror(errno) << endl;exit(0);}// 3、读取数据while (true){char buff[64];int n = read(rfd, buff, sizeof(buff) - 1);buff[n] = '\0';if (n > 0){cout << "Server get message# " << buff << endl;}else if (n == 0){cout << "写端关闭，读端读取到0，终止读端" << endl;break;}else{cout << "读取异常" << endl;break;}}close(rfd);unlink(fifo_name.c_str()); //删除命名管道文件return 0;}
客户端
#include <iostream>#include <cstring>#include <cerrno>#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include "common.h"using namespace std;int main(){// 客户端// 1、打开文件int wfd = open(fifo_name.c_str(), O_WRONLY);if (wfd < 0){cerr << "open fail! errno: " << errno << " | " << strerror(errno) << endl;exit(0);}// 2、写入数据，进行通信char buff[64] = {0};while (true){cout << "Client send message# ";fgets(buff, sizeof(buff) - 1, stdin);buff[strlen(buff) - 1] = '\0'; // 去除 '\n'if (strcasecmp("exit", buff) == 0)break;write(wfd, buff, strlen(buff));}close(wfd);return 0;}
注：strcasecmp是一个字符串比较函数，无论字符串大小写，都能进行比较
运行效果：
所以挂了名之后的命名管道是如何实现独立进程间IPC的呢？
1.2、命名管道的工作原理
把视角拉回文件系统：当重复多次打开同一个文件时，并不会费力的打开多次，而且在第一次打开的基础上，对struct file结构体中的引用计数++，所以对于同一个文件，不同进程打开了，看到的就是同一个
具体例子：显示器文件（stdout）只有一个吧，是不是所有进程都可以同时进行写入？同理，命名管道文件也是如此，先创建出文件，在文件系统中挂个名，然后让独立的进程以不同的方式打开同一个命名管道文件，比如进程A以只读的方式打开，进程B以只写的方式打开，那么此时进程B就可以向进程A写文件，即IPC
因为命名管道适用于独立的进程间IPC，所以无论是读端和写端，进程A、进程B为其分配的fd是一致的，都是3
如果是匿名管道，因为是依靠继承才看到同一文件的，所以读端和写端fd不一样
所以命名管道和匿名管道还是有区别的
1.3、命名管道与匿名管道的区别
不同点：
匿名管道只能用于具有血缘关系的进程间通信；而命名管道不讲究，谁都可以用匿名管道直接通过pipe函数创建使用；而命名管道需要先通过mkfifo函数创建，然后再通过open打开使用出现多条匿名管道时，可能会出现写端fd重复继承的情况；而命名管道不会出现这种情况
在其他方面，匿名管道与命名管道几乎一致
两个都属于管道家族，都是最古老的进程间通信方式，都自带同步与互斥机制，提供的都是流式数据传输
2、命名管道的特点及特殊场景
命名管道的特点及特殊场景与匿名管道完全一致，这里简单回顾下，详细内容可跳转至 《Linux进程间通信【匿名管道】》
2.1、特点
可以简单总结为：
管道是半双工通信管道生命随进程而终止命名管道任意多个进程间通信管道提供的是流式数据传输服务管道自带 同步与互斥 机制
2.2、四种特殊场景
四种场景分别为
管道为空时，读端阻塞，等待写端写入数据管道为满时，写端阻塞，等待读端读取数据进程通信时，关闭读端，OS发出13号信号SIGPIPE终止写端进程进程通信时，关闭写端，读端读取到0字节数据，可以借此判断终止读端
3、命名管道实操
以下是一些使用命名管道实现的简单小程序，主要目的是为了熟悉命名管道的使用
3.1、实现文件拷贝
下载应用的本质是在下载文件，将服务器看作写端，自己的电脑看作读端，那么 下载 这个动作本质上就是IPC，不过是在网络层面实现的
我们可以利用命名管道实现不同进程间IPC，即进程从文件中读取并写入一批数据，另一个进程一次读取一批数据并保存至新文件中，这样就实现了文件的拷贝
目标：利用命名管道，向空文件target.txt中写入数据，即拷贝源文件file.txt
公共资源
common.h
#pragma once#include <iostream>#include <string>std::string fifo_name = "./fifo"; //管道名uint32_t mode = 0666; //权限
服务端（写端）
提供文件拷贝服务
#include <iostream>#include <cstring>#include <cerrno>#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include "common.h"using namespace std;int main(){// 服务端// 1、打开文件int wfd = open(fifo_name.c_str(), O_WRONLY);if (wfd < 0){cerr << "open fail! errno: " << errno << " | " << strerror(errno) << endl;exit(0);}// 2、打开源文件FILE *fp = fopen("file.txt", "r");if (fp == NULL){cerr << "fopen fail! errno: " << errno << " | " << strerror(errno) << endl;exit(0);}// 3、读取源文件数据char buff[1024];int n = fread(buff, sizeof(char), sizeof(buff), fp);//IPC区域// 4、写入源文件至命名管道write(wfd, buff, strlen(buff));cout << "服务端已向管道写入: " << n << "字节的数据" << endl;//IPC区域fclose(fp);fp = nullptr;close(wfd);return 0;}
客户端（读端）
从服务端中拷贝文件（下载）
#include <iostream>#include <cstring>#include <cerrno>#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include "common.h"using namespace std;int main(){// 客户端// 1、创建命名管道文件int ret = mkfifo(fifo_name.c_str(), mode);if (ret < 0){cerr << "mkfifo fail! errno: " << errno << " | " << strerror(errno) << endl;exit(0);}// 2、以读的方式打开管道文件int rfd = open(fifo_name.c_str(), O_RDONLY);if (rfd < 0){cerr << "open fail! errno: " << errno << " | " << strerror(errno) << endl;exit(0);}// 3、打开目标文件FILE *fp = fopen("target.txt", "w");if (fp == NULL){cerr << "fopen fail! errno: " << errno << " | " << strerror(errno) << endl;exit(0);}//IPC区域// 4、读取数据char buff[1024];int n = read(rfd, buff, sizeof(buff) - 1);buff[n] = '\0';if (n > 0)cout << "客户端已从管道读取: " << n << "字节的数据" << endl;else if (n == 0)cout << "写端关闭，读端读取到0，终止读端" << endl;elsecout << "读取异常" << endl;//IPC区域//5、写入目标文件，完成拷贝fwrite(buff, sizeof(char), strlen(buff), fp);cout << "客户端已成功从服务端下载（拷贝）了文件数据" << endl;fclose(fp);close(rfd);unlink(fifo_name.c_str()); // 删除命名管道文件return 0;}
拷贝结果：成功拷贝
此时服务端是写端，客户端是读端，实现的是下载服务；当服务端是读端，客户端是写端时，实现的就是上传服务，搞两条管道就能模拟实现简单的数据双向传输服务
注意：创建管道文件后，无论先启动读端，还是先启动写端，都要阻塞式的等待另一方进行交互
3.2、实现进程控制
在Linux匿名管道IPC中，我们实现了一个简易版的进程控制程序，原理是通过多条匿名管道实现父进程对多个子进程执行任务分配
匿名管道用于有血缘关系间IPC，命名管道也可以
所以我们可以把上一篇文章中的匿名管道换为命名管道，一样可以实现通信
任务池
Task.hpp
#include <iostream>#include <string>#include <functional>#include <unordered_map>#include <unistd.h>using namespace std;void PrintLOG(){cout << "PID: " << getpid() << " 正在执行打印日志的任务…" << endl;}void InsertSQL(){cout << "PID: " << getpid() << " 正在执行数据库插入的任务…" << endl;}void NetRequst(){cout << "PID: " << getpid() << " 正在执行网络请求的任务…" << endl;}class Task{public:Task(){// 装载任务_tt = {{"打印日志", PrintLOG}, {"数据库插入", InsertSQL}, {"网络请求", NetRequst}};}// 展示任务void showTask(){cout << "目前可用任务有：[";for (auto e : _tt)cout << e.first << " ";cout << "]" << endl;cout << "输入 退出 以终止程序" << endl;}// 执行任务void Execute(const string &task){if (_tt.count(task) == 0){cerr << "没有这个任务：" << task << endl;}else{_tt[task](); // 函数对象调用}}private:unordered_map<string, function<void(void)>> _tt;};
控制程序
包括进程、管道创建，任务执行与进程等待
#include <iostream>#include <string>#include <vector>#include <cassert>#include <cstdlib>#include <unistd.h>#include <sys/types.h>#include <sys/wait.h>#include <sys/stat.h>#include <fcntl.h>#include "Task.hpp"using namespace std;enum{NAME_SIZE = 64};// 子进程基本信息类class ProcINfo{public:ProcINfo(pid_t pid = pid_t(), int wfd = int()): _pid(pid), _wfd(wfd), _num(_cnt++){char buff[NAME_SIZE] = {0};snprintf(buff, NAME_SIZE, "Process %d | pid:wfd [%d:%d]", _num, _pid, _wfd);_name = string(buff);}pid_t _pid;int _wfd;int _num;string _name;static int _cnt;};int ProcINfo::_cnt = 0;// 进程控制类class ProcCtrl{public:ProcCtrl(int num = 3, mode_t mode = 0666): _num(num), _mode(mode){// 根据 _num 创建命名管道及子进程CreatPipeAndProc();}~ProcCtrl(){waitProc();}// 创建管道及进程void CreatPipeAndProc(){// 因为是继承的，所以也要注意写端重复继承问题vector<int> fds;for (int i = 0; i < _num; i++){// 步骤：创建管道，存入 _vstchar pipeNameBUff[NAME_SIZE]; // 管道名缓冲区snprintf(pipeNameBUff, NAME_SIZE, "./fifo-%d", i);int ret = mkfifo(pipeNameBUff, _mode);assert(ret != -1);(void)ret;_vst.push_back(string(pipeNameBUff));// 创建子进程，让子进程以只读的方式打开管道文件pid_t id = fork();if (id == 0){// 子进程内// 先关闭不必要的写端for (auto e : fds)close(e);// 打开管道文件，并进入任务等待默认（读端阻塞）int rfd = open(_vst[i].c_str(), O_RDONLY);assert(rfd != -1);(void)rfd;waitCommand(rfd);close(rfd); // 关闭读端exit(0);}// 父进程以写打开管道，保存 fd 信息int wfd = open(_vst[i].c_str(), O_WRONLY);assert(wfd != -1);(void)wfd;// 注册子进程信息_vpt.push_back(ProcINfo(id, wfd));fds.push_back(wfd);}}// 子进程等待任务派发void waitCommand(int rfd){while (true){char buff[NAME_SIZE] = {0};int n = read(rfd, buff, sizeof(buff) - 1);buff[n] = '\0';if (n > 0){Task().Execute(string(buff));}else if (n == 0){cerr << "读端读取到 0，写端已关闭，读端也即将关闭" << endl;break;}else{cerr << "子进程读取异常！" << endl;break;}}}// 展示可选进程void showProc(){cout << "目前可用进程有：[";int i = 0;for (i = 0; i < _num - 1; i++)cout << i << "|";cout << i << "]" << endl;}// 下达任务给子进程void ctrlProc(){while (true){cout << "==========================" << endl;int n = 0;do{showProc();cout << "请选择子进程:> ";cin >> n;} while (n < 0 || n >= _num);Task().showTask();string taskName;cout << "请选择任务:> ";cin >> taskName;if (taskName == "退出")break;// 将信息通过命名管道写给子进程cout << "选择进程 ->" << _vpt[n]._name << " 执行 " << taskName << " 任务" << endl;write(_vpt[n]._wfd, taskName.c_str(), taskName.size());sleep(1);}}// 关闭写端、删除文件、等待子进程退出void waitProc(){for (int i = 0; i < _num; i++){close(_vpt[i]._wfd);// 关闭写端unlink(_vst[i].c_str()); // 关闭管道文件waitpid(_vpt[i]._pid, nullptr, 0); // 等待子进程}cout << "所有子进程已回收" << endl;}private:vector<ProcINfo> _vpt; // 子进程信息表vector<string> _vst; // 命名管道信息表int _num; // 子进程数/命名管道数mode_t _mode;// 命名管道文件的权限};int main(){ProcCtrl p1;p1.ctrlProc();return 0;}
执行结果如下：
关于父子进程间使用命名管道通信值得注意的问题：
在命名管道创建后，需要先创建子进程，让子进程打开【读端或写端】，然后才让父进程打开【写端或读端】，这是因为假如先让父进程打开【写端或读端】，那么此时父进程就会进入【阻塞】状态，导致无法创建子进程，自然也就无法再打开【读端或写端】；所以正确做法是先让子进程打开，即使子进程【阻塞】了，父进程也还能运行。不要让【阻塞】阻碍子进程的创建子进程继承都存在的问题：写端重复继承，因此需要关闭不必要的写端fd
关于问题一的理解可以看看下面这两张图：
错误用法：父进程先打开【写端或读端】，再创建子进程，最后才让子进程打开【读端或写端】
正确用法：先创建子进程，让子进程打开【读端或写端】，再让父进程打开【写端或读端】
3.3、实现进程遥控（配合简易版 bash）
利用命名管道就可以远程遥控，原理很简单：简易版bash会等待命令输入，将输入源换成命名管道读端，再创建一个独立进程，作为命名管道的写端，此时就可以实现远程遥控进程，执行不同的指令
这里直接用之前写好的简易版 bash，关于简易版 bash的具体实现可以看看这篇文章 《Linux模拟实现【简易版bash】》
步骤：
创建命名管道将bash改装，打开命名管道文件，作为读端创建独立进程，打开命名管道文件，作为写端进行IPC，发送命令给bash执行
公共资源
common.h
#pragma once#include <iostream>#include <string>std::string fifo_name = "./fifo"; //管道名uint32_t mode = 0666; //权限
简易版bash
#include <iostream>#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <sys/wait.h>#include <sys/types.h>#include <string.h>#include <assert.h>#include <sys/stat.h>#include <fcntl.h>#include "common.h"using namespace std;#define COM_SIZE 1024#define ARGV_SIZE 64#define DEF_CHAR " "void split(char *argv[ARGV_SIZE], char *ps){assert(argv && ps);// 调用 C语言 中的 strtok 函数分割字符串int pos = 0;argv[pos++] = strtok(ps, DEF_CHAR); // 有空格就分割while (argv[pos++] = strtok(NULL, DEF_CHAR)); // 不断分割argv[pos] = NULL; // 确保安全}void showEnv(){extern char **environ; // 使用当前进行的环境变量表int pos = 0;for (; environ[pos]; printf("%s\n", environ[pos++]));}// 枚举类型，用于判断不同的文件打开方式enum redir{REDIR_INPUT = 0,REDIR_OUTPUT,REDIR_APPEND,REDIR_NONE} redir_type = REDIR_NONE; // 创建对象 redir_type，默认为 NONE// 检查是否出现重定向符char *checkDir(char *command){// 从右往左遍历，遇到 > >> < 就置为 '\0'size_t end = strlen(command); // 与返回值相匹配char *ps = command + end;// 为了避免出现无符号-1，这里采取错位的方法while (end != 0){if (command[end - 1] == '>'){if (command[end - 2] == '>'){command[end - 2] = '\0';redir_type = REDIR_APPEND;return ps;}command[end - 1] = '\0';redir_type = REDIR_OUTPUT;return ps;}else if (command[end - 1] == '<'){command[end - 1] = '\0';redir_type = REDIR_INPUT;return ps;}// 如果不是空格，就可以更新 ps指向if (*(command + end - 1) != ' ')ps = command + end - 1;end--;}return NULL; // 如果没有重定向符，就返回空}int main(){char myEnv[COM_SIZE][ARGV_SIZE]; // 大小与前面有关int env_pos = 0; // 专门维护缓冲区int exit_code = 0;// 保存退出码的全局变量// .6.7 更新// 创建管道文件int ret = mkfifo(fifo_name.c_str(), mode);assert(ret != -1);(void)ret;// 打开管道文件int rfd = open(fifo_name.c_str(), O_RDONLY);assert(rfd != -1);(void)rfd;// 这是一个始终运行的程序：bashwhile (1){char command[COM_SIZE]; // 存放指令的数组（缓冲区）// 打印提示符printf("[User@myBash default]$ ");fflush(stdout);// 读取指令//从管道中读取int n = read(rfd, command, COM_SIZE - 1);if(n == 0){cout << "写端已关闭，读端也即将关闭" << endl;break;}command[n] = '\0';cout << command << endl;// 重定向// 在获取指令后进行判断// 如果成立，则获取目标文件名 filenamechar *filename = checkDir(command);// 指令分割// 将连续的指令分割为 argv 表char *argv[ARGV_SIZE];split(argv, command);// 特殊处理// 颜色高亮处理，识别是否为 ls 指令if (strcmp(argv[0], "ls") == 0){int pos = 0;while (argv[pos++]);// 找到尾argv[pos - 1] = (char *)"--color=auto"; // 添加此字段argv[pos] = NULL; // 结尾}// 目录间移动处理if (strcmp(argv[0], "cd") == 0){// 直接调用接口，然后 continue 不再执行后续代码if (strcmp(argv[1], "~") == 0)chdir("/home"); // 回到家目录else if (strcmp(argv[1], "-") == 0)chdir(getenv("OLDPWD"));else if (argv[1])chdir(argv[1]); // argv[1] 中就是路径continue; // 终止此次循环}// 环境变量相关if (strcmp(argv[0], "export") == 0){if (argv[1]){strcpy(myEnv[env_pos], argv[1]);putenv(myEnv[env_pos++]);}continue; // 一样需要提前结束循环}// 环境变量表if (strcmp(argv[0], "env") == 0){showEnv(); // 调用函数，打印父进程的环境变量表continue; // 提前结束本次循环}// echo 相关// 只有 echo $ 才做特殊处理（环境变量+退出码）if (strcmp(argv[0], "echo") == 0 && argv[1][0] == '$'){if (argv[1] && argv[1][0] == '$'){if (argv[1][1] == '?')printf("%d\n", exit_code);elseprintf("%s\n", getenv(argv[1] + 1));}continue;}// 子进程进行程序替换pid_t id = fork();if (id == 0){// 判断是否需要进行重定向if (redir_type == REDIR_INPUT){int fd = open(filename, O_RDONLY);dup2(fd, 0); // 更改输入，读取文件 filename}else if (redir_type == REDIR_OUTPUT){int fd = open(filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);dup2(fd, 1); // 写入}else if (redir_type == REDIR_APPEND){int fd = open(filename, O_WRONLY | O_CREAT | O_APPEND, 0666);dup2(fd, 1); // 追加}// 直接执行程序替换，这里使用 execvpexecvp(argv[0], argv);exit(168); // 替换失败后返回}// 父进程等待子进程终止int status = 0;waitpid(id, &status, 0); // 在等待队列中阻塞exit_code = WEXITSTATUS(status);if (WIFEXITED(status)){// 假如程序替换失败if (exit_code == 168)printf("%s: Error - %s\n", argv[0], "The directive is not yet defined");}elseprintf("process run fail! [code_dump]:%d [exit_signal]:%d\n", (status >> 7) & 1, status & 0x7F); // 子进程异常终止的情况}//关闭管道文件close(rfd);unlink(fifo_name.c_str());return 0;}
进程控制端
#include <iostream>#include <cassert>#include <cstring>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include <unistd.h>#include "common.h"using namespace std;int main(){// 打开管道文件 --- 只写int wfd = open(fifo_name.c_str(), O_WRONLY);assert(wfd != -1);(void)wfd;char buff[64];while (true){cout << "远程发送指令:> ";fgets(buff, sizeof(buff) - 1, stdin);buff[strlen(buff) - 1] = '\0'; // 去除 '\n'if (strcasecmp("exit", buff) == 0)break;// 向管道写入数据write(wfd, buff, strlen(buff));}close(wfd);return 0;}
实际效果如下：
注意：在进行指令处理时，需要注意'\n'，不能把'\n'带入进程替换中
3.4、实现字符实时读取
回车'\n'这个东西很难处理，那么有没有一种方式，能实现不输入回车也能写入数据至管道中呢？答案是有的
比如以下代码，可以实现特殊化读取，即不需要特点条件触发缓冲区冲刷，实时写入字符
公共资源
common.h
#pragma once#include <iostream>#include <string>std::string fifo_name = "./fifo"; //管道名uint32_t mode = 0666; //权限
服务端
实时读取字符
#include <iostream>#include <cstring>#include <cerrno>#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include "common.h"using namespace std;int main(){// 服务端// 1、创建命名管道文件int ret = mkfifo(fifo_name.c_str(), mode);if (ret < 0){cerr << "mkfifo fail! errno: " << errno << " | " << strerror(errno) << endl;exit(0);}// 2、以读的方式打开文件int rfd = open(fifo_name.c_str(), O_RDONLY);if (rfd < 0){cerr << "open fail! errno: " << errno << " | " << strerror(errno) << endl;exit(0);}// 3、读取数据while (true){char buff[64];int n = read(rfd, buff, sizeof(buff) - 1);buff[n] = '\0';if (n > 0){buff[n] = 0;printf("%c", buff[0]);fflush(stdout);}else if (n == 0){cout << "写端关闭，读端读取到0，终止读端" << endl;break;}else{cout << "读取异常" << endl;break;}}close(rfd);unlink(fifo_name.c_str()); // 删除命名管道文件return 0;}
客户端
实时发送字符
#include <iostream>#include <cstring>#include <cerrno>#include <cassert>#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>#include "common.h"using namespace std;int main(){// 客户端// 1、打开文件int wfd = open(fifo_name.c_str(), O_WRONLY);if (wfd < 0){cerr << "open fail! errno: " << errno << " | " << strerror(errno) << endl;exit(0);}// 2、写入数据，进行通信char buff[64] = {0};while (true){system("stty raw");int c = getchar();system("stty -raw");ssize_t n = write(wfd, (char *)&c, sizeof(char));assert(n >= 0);(void)n;}close(wfd);return 0;}
实时读取字符的效果如下：
本文中涉及的所有代码均在此仓库中：《命名管道博客仓库》
🌆总结
以上就是本次关于Linux进程间通信之命名管道的全部内容了，作为匿名管道的兄弟，命名管道具备匿名管道的大部分特性，使用方法也基本一致，不过二者在创建和打开方式上各有不同：匿名管道简单，但只能用于具有血缘关系进程间通信，命名管道虽麻烦些，但适用于所有进程间通信场景；在本文的最后，使用命名管道实现了几个简单的小程序，这些小程序的本质都是一样的：创建命名管道 -> 打开命名管道 -> 通信 -> 关闭命名管道，掌握其中一个即可融会贯通
相关文章推荐
Linux进程间通信【匿名管道】
Linux基础IO【软硬链接与动静态库】
Linux基础IO【深入理解文件系统】
Linux【模拟实现C语言文件流】
Linux基础IO【重定向及缓冲区理解】
Linux基础IO【文件理解与操作】
