• [Linux打怪升级之路]-管道

    前言

    作者：小蜗牛向前冲

    名言：我可以接受失败，但我不能接受放弃

      如果觉的博主的文章还不错的话，还请点赞，收藏，关注👀支持博主。如果发现有问题的地方欢迎❀大家在评论区指正

    本期学习目标：理解什么是管道，学会使用匿名管道和命名管道进行通信

    在学习管道之前，我们要明白在Llinux下，什么是通信

    一、通信

    我们都知道进程具有独立性，也就是说在进程A的执行的信息是不会被B知晓的，但是在以一下场景需要进程间信息：

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

    那为什么要有通信呢？ 

    从进程通信的目的来说，我们大体可以理解为通信的目标其实就是让一个进程的消息被另外一个进程所知晓。 

    比如多进程协同的：

    1. cat file | grep "hello world"
    2. //cat将file文件中的内容打印到屏幕上
    3. // | 管道
    4. // gerp匹配并输出满足指定模式条件的行

    这个命令要完成需要二个进程共同协作，也就是说有一些信息双方都要知道，我们就通过管道(|) ,将信息共享了。

    那我们又该如何理解通信的问题：

    既然进程具有独立性，也就是说双方是不可能直接通信的，就必须有一个第三方的介入，这个第三方就要由操作系统来完成。

    • OS需要直接或者间接给通信双方的进程提供 "大家都可以看到一块内存空间"。
    • 要通信的进程，必须必须看到一份公共资源。

    那么通信操作系统是怎么完成的呢？

    所以在操作系统这一般有三种通信手段：

    • System v进程间通信（聚焦在本地通信）
    • POSIX进程间通信（让通信过程可以跨主机）
    • 管道

    下面我们将重点为大家讲述，管道是如何进行通信的。

    二、管道

    1、什么是管道

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

    下面我们通过一张图来理解一下管道 

    •  who 是 Linux 中的一个命令，用于显示当前登录系统的用户信息
    •  wc -l 是 Linux 中的一个命令，用于统计文件中的行数。wc 是 word count（词频统计）的缩写，-l 选项表示只统计行数。
    • who | wc -l 是 Linux 中的一个命令，通过管道符 | 结合 who 和 wc 两个命令，实现统计当前登录系统的用户数量。

    对于管道我们又分为二类：

    •  匿名管道pipe
    • 命名管道

    2、匿名管道pipe

    匿名管道他的概念顾明思意：创建一无名的管道

    原型：

    int pipe(int fd[2]);
    参数
    fd：文件描述符数组,其中fd[0]表示读端, fd[1]表示写端
    返回值:成功返回0，失败返回错误代码

    为了方便记忆，我们可以把0想象成嘴巴，所以是读端， 把1想象成笔，所以是写端。

     

     注意：

    • 匿名管道只能用于有亲缘关系的进程间通信，也就是说，只能用于父子进程或者兄弟进程之间。
    • 匿名管道是由内核中的一块缓冲区实现的，该缓冲区分别由两个文件描述符指向，一个用于读取数据，一个用于写入数据。
    • 因为是匿名的，所以无法通过文件系统访问它们

    3、对匿名管道的理解 

    匿名管道是如何实现通信的呢？

    首先父进程创建管道

    其次父进创建子进程 

    最后父进程关闭fd[0]（读端）子进程关闭fd[1]（写端) 

    这样就完成管道的单向通信。

     为验证管道探究管道单向通信读写的特点，完成以下代码：

    由父进程创建管道，fork出子进程，在让子进程关闭读端，让子进程写入信息道管道中，父进程关闭写端，从管道中读取信息。

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. using namespace std;
    12. int main()
    13. {
    14.     //创建管道，打开读写端
    15.     int fds[2];
    16.     int n = pipe(fds);
    17.     assert(n == 0 );
    18.  
    19.     //创建子进程
    20.     pid_t id = fork();
    21.     assert(id>=0);
    22.     if(id == 0)
    23.     {
    24.         //子进程写入
    25.         close(fds[0]);
    26.         const char *s = "hellow parent";
    27.         int cnt = 0;
    28.         while(true)
    29.         {
    30.             cnt++;
    31.             char buffer[1024];//子进程才可以看到的数组
    32.             //向buffer数组这写入数组
    33.             snprintf(buffer,sizeof buffer,"child->parent say: %s[%d][%d]",s,cnt,getpid());
    34.             write(fds[1],buffer,strlen(buffer));
    35.             sleep(1);//每隔1秒写入
    36.             //当父进程不读，子进程的管道空间是有限的会满
    37.             // cout<< cnt <
    38.         }
    39.  
    40.  
    41.         //子进程关闭写端
    42.         close(fds[1]);
    43.         cout<<"子进程关闭写端"<
    44.         exit(0);
    45.     }
    46.  
    47.     //父进程读取
    48.     close(fds[1]);
    49.     while(true)
    50.     {
    51.         char buffer[1024];
    52.         ssize_t s = read(fds[0],buffer,sizeof(buffer)-1);
    53.         if(s > 0)
    54.         {
    55.             buffer[s] = 0;
    56.             cout<<"Get Message#"<" | my pid: "<<getpid()<
    57.         }
    58.         else if(s == 0)
    59.         {
    60.             //读到文件结尾
    61.             cout<<"read: "<
    62.             break;
    63.         }
    64.     }
    65.     close(fds[0]);
    66.     cout<<"父进程关闭了读端"<
    67.  
    68.     n = waitpid(id,nullptr,0);
    69.     assert(n == id);
    70.     
    71.     return 0;
    72. }

    下面的探究都是具居于上面代码的简单修改 

    探究1、子进程写的快，父进程读的慢 

     我们发现管道会被写满，写端写满的时候，在写会阻塞，等对方进行读取

    结论：管道的空间是有限的会被写满

     探究2、子进程写的慢，父进程读的快 

     这里我们是让子进程每隔5秒才写入，而父进程在读取前打印A,读取后打印B

    这里我们发现在子进程没有写入时，父进程会阻塞等待子进程写入。 

      探究3、子进程直接将写端关闭

     这时候我们发现父进程会读到0，从而结束读取。

      探究4、子进程写，但是父进程不读

        cout <<"pid->"<< n << " : "<< (status & 0x7F) << endl;

    status 是一个整型变量，它用于存储进程的退出状态信息。在 Linux 中，进程终止时，会向其父进程发送一个信号，该信号包含了进程退出的原因以及退出状态码。通过位运算 status & 0x7F，可以得到进程退出的原因，即低 7 位二进制数对应的十进制数，该数字通常被称为“终止信号” 

    这里打印的是进程的pid和 退出状态信息

    那进程退出13号退出信息又代表什么意思呢？ 

    我们kill-l一下

    也就是说当读端关闭了，操作系统会 给进程发13) SIGPIPE的信息，从而终止写端。

    根据以上场景的探究，下面我们归纳一下匿名管道的特点：

    • 只能用于具有共同祖先的进程（具有亲缘关系的进程）之间进行通信；通常，一个管道由一个进程创建，然后该进程调用fork，此后父、子进程之间就可应用该管道。
    • 管道提供流式服务
    • 一般而言，进程退出，管道释放，所以管道的生命周期随进程
    • 一般而言，内核会对管道操作进行同步与互斥
    • 管道是半双工的，数据只能向一个方向流动；需要双方通信时，需要建立起两个管

    三、基于匿名管道的进程池设计 

    为了更好的理解管道的应用，下面将带领大家设计一个基于管道的进程池设计。

    实现现象：通过一个父进程，随意的控制一个子进程完成我们的相关操作。

    1、main函数主体

    在函数主体中我们，要完成程序整体框架的搭建。首先，建立子进程并建立和子进程的通信的信道，其次，父进程，控制子进程，向子进程发命令码，最后，回收进程。

    1. int main()
    2. {
    3.     MakeSeed();//生产随机数的种子
    4.     //1.建立子进程并建立和子进程的通信的信道
    5.     //1.1加载
    6.     std::vector<func_t> funcMap;//用于存放子进程执行函数的地址
    7.     loadTaskFunc(&funcMap);
    8.     //1.2 创建子进程，并且维护好父子进程的通道
    9.     std::vector subs;
    10.     createSubProcess(&subs,funcMap);
    11.  
    12.     //父进程，控制子进程，向子进程发命令码
    13.     int taskCnt = 3;//3表示子进程执行3次
    14.     loadBlanceContrl(subs,funcMap,taskCnt);
    15.  
    16.     //回收进程
    17.     waitProcces(subs);
    18.     return 0;
    19. }

    2、各项函数功能的实现 

    2.1、建立子进程并建立和子进程的通信的信道

    void createSubProcess(std::vector *subs, std::vector &funcMap)

    在创建子进程的函数中，我们传了二个参数 ，*subs和&funcMap。

    subs指针指向的是父进程管理子进程各项信息的类：

    1. class subEp//父进程的一些控制信息
    2. {
    3.     public:
    4.     subEp(pid_t subId,int writeFd )
    5.     : _subId(subId),_writeFd(writeFd)
    6.     {
    7.         char nameBuffer[1024];
    8.         snprintf(nameBuffer,sizeof(nameBuffer),"process-%d[pid(%d)-fd(&d)]", _num++, _subId, _writeFd);
    9.         _name = nameBuffer;
    10.         
    11.     }
    12.     public:
    13.     static int _num;
    14.     std::string _name;
    15.     pid_t _subId;
    16.     int _writeFd;
    17. };
    18.  
    19. int subEp::_num = 0;

     funcMap是子进程要执行的任务：

    1.     std::vector funcMap;//用于存放子进程执行函数的地址
    2.     loadTaskFunc(&funcMap);

    其中的funcMap是一个数组，数组中存放的是指向父进程要子进程执行的任务函数指针。 

    1. //函数指针
    2. typedef void (*func_t)();
    3.  
    4. void downLodeTask()
    5. {
    6.     std::cout<<getpid()<<"下载任务\n"
    7.              <
    8.     sleep(1);
    9. }
    10.  
    11. void ioTask()
    12. {
    13.     std::cout<<getpid()<<"io任务\n"
    14.              <
    15.     sleep(1);
    16. }
    17.  
    18. void flushTask()
    19. {
    20.     std::cout<<getpid()<<"刷新任务\n"
    21.              <
    22.     sleep(1);
    23. }
    24.  
    25. void loadTaskFunc(std::vector<func_t> *out)
    26. {
    27.     assert(out);
    28.     out->push_back(downLodeTask);
    29.     out->push_back(ioTask);
    30.     out->push_back(flushTask);
    31. }

     子进程接受任务函数

    1. int recvTask(int readFd)
    2. {
    3.     int code = 0;
    4.     ssize_t s = read(readFd,&code,sizeof(code));
    5.     if(s == 4) return  code;
    6.     else if(s <= 0) return -1;
    7.     else return 0;
    8. }

    下面是创建子进程代码的完整实现 

    1. void createSubProcess(std::vector *subs, std::vector<func_t> &funcMap) 
    2. {
    3.     std::vector<int> deleteFd;
    4.     for(int i = 0; i < PROCESS_NIM;i++)
    5.     {
    6.         int fds[2];
    7.         int n = pipe(fds);
    8.         assert(n == 0);
    9.         //因为assert是Dug版本显示，reserve版本不显示，其中的n是pipe的返回值
    10.         //在reserve版本下，编译器可能认为n一个函数的返回值没有被使用，可能会有warn
    11.         (void)n;
    12.         pid_t id = fork();
    13.         if(id == 0)
    14.         {
    15.             for(int i = 0; i < deleteFd.size(); i++) close(deleteFd[i]);
    16.             //子进程处理任务
    17.              close(fds[1]);
    18.              while(true)
    19.              {
    20.                 //获取命令码
    21.                 int commandCode = recvTask(fds[0]);
    22.  
    23.                 //完成任务
    24.                 if(commandCode >= 0 && commandCode size())
    25.                 {
    26.                     funcMap[commandCode]();
    27.                 }
    28.                 else if(commandCode ==-1)
    29.                 {
    30.                     break;
    31.                 }
    32.              }
    33.              exit(0);
    34.         }
    35.         close(fds[0]);
    36.         subEp sub(id,fds[1]);
    37.         subs->push_back(sub);
    38.         deleteFd.push_back(fds[1]);
    39.     }
    40. }

     2.2、父进程控制子进程，向子进程发命令码

    1.   int taskCnt = 3;//3表示子进程执行3次
    2.     loadBlanceContrl(subs,funcMap,taskCnt);

    其中父进程控制子进程函数的第三个参数是我们要子进程执行几个任务。

    父进程发送给子进程任务的控制函数

    1.     void sendTask(const subEp &process,int taskNum)
    2.     {
    3.         std::cout<<"send task num: "<< taskNum << " send to -> "<< process._name <
    4.         int n = write(process._writeFd,&taskNum,sizeof(taskNum));
    5.         assert(n == sizeof(int));
    6.         (void)n;
    7.     }

     父进程控制子进程的代码：

    1.     void loadBlanceContrl(const std::vector &subs,const std::vector<func_t> &funcMap,int count)
    2.     {
    3.         int processnum = subs.size();
    4.         int tasknum = funcMap.size();
    5.         bool forever = (count == 0 ? true : false);
    6.         while(true)
    7.         {
    8.             //选择一个子进程  --》std::vector ->index 
    9.             int subIdx = rand() % processnum;
    10.             //选择一个任务
    11.             int taskIdx = rand() % tasknum;
    12.             //将任务发送给选项的进程
    13.             sendTask(subs[subIdx],taskIdx);
    14.             sleep(1);
    15.             //控制子进程的执行任务的次数
    16.             if(!forever)
    17.             {
    18.                 count--;
    19.                 if(count == 0) break;
    20.             }
    21.         }
    22.         for(int i = 0; iclose(subs[i]._writeFd);
    23.     }

     2.3、回收进程

     waitProcces(subs);
    1. void waitProcces(std::vector processes)
    2. {
    3.     int processnum = processes.size();
    4.     for(int i = 0; i < processnum; i++)
    5.     {
    6.         waitpid(processes[i]._subId,nullptr,0);
    7.         std::cout<<"wait sub process success ..." << processes[i]._subId << std::endl;
    8.     }
    9. }

    2.4、代码的完整实现 

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. #define PROCESS_NIM 5
    12.  
    13. #define MakeSeed() srand((unsigned long)time(nullptr)^getpid()^0x324124^rand()%1234)
    14. //下面代码是子进程要完成的任务//
    15. //函数指针
    16. typedef void (*func_t)();
    17.  
    18. void downLodeTask()
    19. {
    20.     std::cout<<getpid()<<"下载任务\n"
    21.              <
    22.     sleep(1);
    23. }
    24.  
    25. void ioTask()
    26. {
    27.     std::cout<<getpid()<<"io任务\n"
    28.              <
    29.     sleep(1);
    30. }
    31.  
    32. void flushTask()
    33. {
    34.     std::cout<<getpid()<<"刷新任务\n"
    35.              <
    36.     sleep(1);
    37. }
    38.  
    39. void loadTaskFunc(std::vector<func_t> *out)
    40. {
    41.     assert(out);
    42.     out->push_back(downLodeTask);
    43.     out->push_back(ioTask);
    44.     out->push_back(flushTask);
    45. }
    46. //下面代码是多进程的程序///
    47. class subEp//父进程的一些控制信息
    48. {
    49.     public:
    50.     subEp(pid_t subId,int writeFd )
    51.     : _subId(subId),_writeFd(writeFd)
    52.     {
    53.         char nameBuffer[1024];
    54.         snprintf(nameBuffer,sizeof(nameBuffer),"process-%d[pid(%d)-fd(&d)]", _num++, _subId, _writeFd);
    55.         _name = nameBuffer;
    56.         
    57.     }
    58.     public:
    59.     static int _num;
    60.     std::string _name;
    61.     pid_t _subId;
    62.     int _writeFd;
    63. };
    64.  
    65. int subEp::_num = 0;
    66.  
    67. int recvTask(int readFd)
    68. {
    69.     int code = 0;
    70.     ssize_t s = read(readFd,&code,sizeof(code));
    71.     if(s == 4) return  code;
    72.     else if(s <= 0) return -1;
    73.     else return 0;
    74. }
    75.  
    76. void createSubProcess(std::vector *subs, std::vector<func_t> &funcMap) 
    77. {
    78.     std::vector<int> deleteFd;
    79.     for(int i = 0; i < PROCESS_NIM;i++)
    80.     {
    81.         int fds[2];
    82.         int n = pipe(fds);
    83.         assert(n == 0);
    84.         //因为assert是Dug版本显示，reserve版本不显示，其中的n是pipe的返回值
    85.         //在reserve版本下，编译器可能认为n一个函数的返回值没有被使用，可能会有warn
    86.         (void)n;
    87.         pid_t id = fork();
    88.         if(id == 0)
    89.         {
    90.             for(int i = 0; i < deleteFd.size(); i++) close(deleteFd[i]);
    91.             //子进程处理任务
    92.              close(fds[1]);
    93.              while(true)
    94.              {
    95.                 //获取命令码
    96.                 int commandCode = recvTask(fds[0]);
    97.  
    98.                 //完成任务
    99.                 if(commandCode >= 0 && commandCode size())
    100.                 {
    101.                     funcMap[commandCode]();
    102.                 }
    103.                 else if(commandCode ==-1)
    104.                 {
    105.                     break;
    106.                 }
    107.              }
    108.              exit(0);
    109.         }
    110.         close(fds[0]);
    111.         subEp sub(id,fds[1]);
    112.         subs->push_back(sub);
    113.         deleteFd.push_back(fds[1]);
    114.     }
    115. }
    116.     
    117.     void sendTask(const subEp &process,int taskNum)
    118.     {
    119.         std::cout<<"send task num: "<< taskNum << " send to -> "<< process._name <
    120.         int n = write(process._writeFd,&taskNum,sizeof(taskNum));
    121.         assert(n == sizeof(int));
    122.         (void)n;
    123.     }
    124.  
    125.     void loadBlanceContrl(const std::vector &subs,const std::vector<func_t> &funcMap,int count)
    126.     {
    127.         int processnum = subs.size();
    128.         int tasknum = funcMap.size();
    129.         bool forever = (count == 0 ? true : false);
    130.         while(true)
    131.         {
    132.             //选择一个子进程  --》std::vector ->index 
    133.             int subIdx = rand() % processnum;
    134.             //选择一个任务
    135.             int taskIdx = rand() % tasknum;
    136.             //将任务发送给选项的进程
    137.             sendTask(subs[subIdx],taskIdx);
    138.             sleep(1);
    139.             //控制子进程的执行任务的次数
    140.             if(!forever)
    141.             {
    142.                 count--;
    143.                 if(count == 0) break;
    144.             }
    145.         }
    146.         for(int i = 0; iclose(subs[i]._writeFd);
    147.     }
    148.  
    149.  
    150. void waitProcces(std::vector processes)
    151. {
    152.     int processnum = processes.size();
    153.     for(int i = 0; i < processnum; i++)
    154.     {
    155.         waitpid(processes[i]._subId,nullptr,0);
    156.         std::cout<<"wait sub process success ..." << processes[i]._subId << std::endl;
    157.     }
    158. }
    159.  
    160. int main()
    161. {
    162.     MakeSeed();
    163.     //1.建立子进程并建立和子进程的通信的信道
    164.     //1.1加载
    165.     std::vector<func_t> funcMap;//用于存放子进程执行函数的地址
    166.     loadTaskFunc(&funcMap);
    167.     //1.2 创建子进程，并且维护好父子进程的通道
    168.     std::vector subs;
    169.     createSubProcess(&subs,funcMap);
    170.  
    171.     //父进程，控制子进程，向子进程发命令码
    172.     int taskCnt = 3;//3表示子进程执行3次
    173.     loadBlanceContrl(subs,funcMap,taskCnt);
    174.  
    175.     //回收子进程
    176.     waitProcces(subs);
    177.     return 0;
    178. }

     3、实验现象

    当我们用父进程控制三个子进程，让他们分别执行任务：

    四、命名管道 

    什么我们用匿名管道进行了进程间的通信，但是匿名管道有限制就是只能在具有共同祖先（具有亲缘关系）的进程间通信。
    如果我们想在不相关的进程之间交换数据，可以使用FIFO文件来做这项工作，那我们就要用到命名管道

    1、命名管道的相关知识

    首先我们要清楚命名管道是一种特殊类型的文件

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

     mkfifo filename

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

    nt mkfifo(const char *filename,mode_t mode)

    命名管道的打开规则

     如果当前打开操作是为读而打开FIFO时

     O_NONBLOCK disable：阻塞直到有相应进程为写而打开该FIFO
    O_NONBLOCK enable：立刻返回成功

    如果当前打开操作是为写而打开FIFO时

     O_NONBLOCK disable：阻塞直到有相应进程为读而打开该FIFO
    O_NONBLOCK enable：立刻返回失败，错误码为ENXIO

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

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

    2、用命令管道实现二个进程通信

    简述：这里我们写二个文件server和linent，让他在命令管道实现进程通信。

    首先我们用makefile来管理我们的多文件

    makefile

    1. .PHONY:all
    2. all:server client
    3.  
    4. server:server.cc
    5. 	g++ -o $@ $^ -std=c++11 -g
    6. client:client.cc
    7. 	g++ -o $@ $^ -std=c++11 -g
    8. .PHONY:clean
    9. clean:
    10. 	rm -f server client

     其次我们要创建命名管道，这里我们定义为comm.hpp，里面包含了server和client二个进程所需要的头文件。当然我们不仅仅写了建立命名管道的函数还有移除管道的函数。

    1. pragma once
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12.  
    13.  
    14. #define NAME_PIPE "/tmp/mypipe.me"
    15.  
    16. bool createFifo(const std::string &path)
    17. {
    18.     umask(0);
    19.     int n = mkfifo(path.c_str(),0600);
    20.     if(n == 0)
    21.     return true;
    22.     else
    23.     {
    24.         std::cout<<"errno: " << errno << " err string: "<< strerror(errno) << std::endl;
    25.         return false;
    26.     }
    27. }
    28.  
    29. void removeFifo(const std::string &path)
    30. {
    31.     int n = unlink(path.c_str());
    32.     assert(n == 0);
    33.     (void)n;
    34. }

    最后就是我们server和client二个通信文件编写：

    server.cc

    在这个文件中，我们要创建命名管道，打开文件(命名管道)，从里面读取我们需要的信息(clicent发送过来)

    1. #include"comm.hpp"
    2.  
    3. int main()
    4. {
    5.     bool r = createFifo(NAME_PIPE);
    6.     assert(r);
    7.     (void)r;
    8.  
    9.     std::cout<< "server begin" << std::endl;
    10.     int rfd = open(NAME_PIPE,O_RDONLY);
    11.     std::cout<< "server end" << std::endl;
    12.     if(rfd<0) exit(1);
    13.  
    14.     char buffer[1024];
    15.     while(true)
    16.     {
    17.         ssize_t s = read(rfd,buffer,sizeof(buffer)-1);
    18.         if(s > 0)
    19.         {
    20.             buffer[s] = 0;
    21.             std::cout << "client->server# " << buffer << std::endl;
    22.         }
    23.         else if(s == 0)
    24.         {
    25.             std::cout << "client quit, me too !" <
    26.             break;
    27.         }
    28.         else
    29.         {
    30.             std::cout << "err string " << strerror(errno) << std::endl;
    31.             break;
    32.         }
    33.     }
    34.  
    35.     close(rfd);
    36.     sleep(10);
    37.     removeFifo(NAME_PIPE);
    38.     return 0;
    39. }

     clicent.cc

    这个文件中我们只有打开刚刚server创建的文件，然后写入信息,server就可以接受到了

    1. #include"comm.hpp"
    2.  
    3. int main()
    4. {
    5.     std:: cout <<" clinent begin " << std::endl;
    6.     int wfd = open(NAME_PIPE,O_WRONLY);
    7.     std::cout << " client end " << std::endl;
    8.     if(wfd < 0) exit(1);
    9.  
    10.     char buffer[1024];
    11.     while(true)
    12.     {
    13.         std::cout << "Please Say# ";
    14.         fgets(buffer,sizeof(buffer),stdin);
    15.         if(strlen(buffer) > 0) buffer[strlen(buffer)-1] = 0;
    16.         ssize_t n = write(wfd,buffer ,strlen(buffer));
    17.         assert( n == strlen(buffer));
    18.         (void)n;
    19.     }
    20.  
    21.     close(wfd);
    22.     return 0;
    23. }

    实验现象：

     这里我们让 clicen进程输入文字就可以在rerver文件中接收到

  • 相关阅读:
    [python]常用配置读取方法
    Mip-NeRF：抗混叠的多尺度神经辐射场ICCV2021
    jolt语法
    c++ day 4
    如何做好数据全生命周期管理，从哪几个方面做？_光点科技
    ArrayList和LinkedList对比，ArrayList使用注意事项
    android端MifareClassicTool
    ​构建“顶流”合作圈，这家车联网企业已提前入局“半决赛”
    vue2 顶象 安全 验证码的使用
    废液收集系统物联网远程监控解决方案
  • 原文地址：https://blog.csdn.net/qq_61552595/article/details/133754183