命名管道Linux

管道是

毫不相关的进程进程间通信::命名管道

管道

首先自己要用用户层缓冲区，还得把用户层缓冲区拷贝到管道里，（从键盘里输入数据到用户层缓冲区里面），然后用户层缓冲区通过系统调用（write）写到管道里，然后再通过read系统调用，被对方（读端）读取，就要从管道拷贝到读端，然后再显示到显示器上。

mkfifo命名管道

1号手册是指令，。2号系统调用接口

创建一个管道，p开头就是命名管道，并不会直接刷新到磁盘中，实际是个符号

这样会阻塞

这样会显示出来（先输入左边的，再输入右边的就会显示），左右两边是两个进程

追加写入的方式，但空间一直是0

所以这就是文件里大小一直是0的原因

你怎么知道打开的是同一个文件

正好符合前提

所以要创建两个可执行程序，各自跑各自的，创建一个common是为了方便使用头文件

client是客户 server是服务者

makefile中一下运行两个程序

mkfifo，用程序的方式创建管道，第一个参数是要创建的这个管道在那个路径下叫什么名字，也就是要保持唯一性的那些点，第二个是创建一个管道

这里是3号手册是函数。

返回 -1创建失败

创建一个共享文件

./myfifo

server.cc和client.cc想看到同一个文件，包含上头文件就可以了

这里先用server控制管道文件

创建管道失败了设置为1 ,如果失败了就exit(1)

谁控制的先运行运行谁就好了

make一下生成两个可执行程序,因为是server控制的，所以要先运行server

运行后就会多一个myfifo命名管道

命名管道的删除

想删除这个myfifo用unlink(成功返回0 ，失败返回-1）

命令行删除

代码也可以删(成功返回0 ，失败返回-1)，头文件是unistd.h

创建完文件，5秒后就删除了

思路

用到了open

打开管道文件，第二个参数是只进行读取

enum中

fd<0打开失败了

服务端读取数据

客户端，只要用就行

第二个参数就是打开文件为了写入的

用户输入完成以后，就要发送输入的消息到另一端

打开顺序一定

然后打开的顺序就一定了，先打开server，然后再打开另一个cc

先打开服务端，会阻塞在这里，然后再打开客户端，进行输入

右边输入啥，左边就会有啥

无法输入空格问题（getline）

但有一个问题就是cin没法输入空格，，要用到getline

会发现一个问题，客户端退出了，服务端还没退出

客户端退出，会read到0，所以服务端（读端）也要退出

改正

sever端

等待写入方式打开后，自己才会打开文件，向后执行，open阻塞了！

优化一下

写成进程池的样子

日志

创建一个新文件

用到了可变参数(形参实例化是从右到左)

可变参数必须右至少一个具体的参数

举个例子：步骤：s指向可变部分

这里的sum第一个参数是几个数求和的意思，传不同的类型不可以的，因为上面va_arg里已经写死了

开始写日志，level日志等级

先定义时间，time，时间戳

ctime

头文件

打印具体年月日

年是从1900年开始的

年月日时分秒

vsnprint

vsnprint，跟不带v的区别就是，去除了...换成了可变参数部分

把日记等级转换成字符串风格,所有有可能的地方都需要返回

改进

va_start(s,format)，用format修饰s的指向，上面的sum是（s,n),类似

这里要用c_str，因为返回的是string

用完以后再用end

这里是往显示器打印的,这里要*3，以为%s和%s中间有几个空格，空间不够

把这里修改一下,打开失败的话

这样就形成日志了

打印最后一行就是正常打开

这里也改一下

测试，先./server，然后会阻塞，然后./client，就会打印出,logmessage里的信息

为啥./client之前不打印

因为等待写入方式打开后，自己才会打开文件，向后执行，open阻塞了！

往文件里打印（上面是往屏幕打印）

先把这些内容全放在Log,日志类

分类

1：向屏幕打印

2：向一个文件打印

3：分类打印

打印格式printMethod

这里构造默认往屏幕去印

析构

打印方式也改一下

打印单个

以0666的权限打开这个文件

打印多个文件（添加一下level）

实现一下

优化一下

以后再打印日志就不用这样打了

这样就可以了，要记住先创建一个Log对象

这样以后就写入一个文件了，写入log.txt

这样就把日志分类了

结果

但是日志文件这么多太混乱了

这样操作后就统一进入一个文件了

makefile也修改一下，先把path定义的log目录创建一下

日志放入一个文件测试结果：

日志分类测试结果：

log.hpp里头文件

优化一下调用

然后修改一下server.cc

client.cc

#include "common.hpp"
#include "log.hpp"
int main()
{
    int fd = open(FIFO_FILE,O_WRONLY);
    if(fd < 0)
    {
        perror("open");
        exit(FIFO_OPEN_ERR);
    }
    string line;
    while(true)
    {
        cout<< "Please Enter@ ";
        // cin>> line;
        getline(cin, line);
        write(fd, line.c_str(),line.size());
    }
    close(fd);
    return 0;
}

common.hpp

#pragma noce
#include<iostream>
#include<vector>
#include<string>
#include<unistd.h>
#include <sys/types.h>
#include <sys/wait.h> 
#include <sys/stat.h>
#include<fcntl.h>
#include<stdio.h>
using namespace std;
#define FIFO_FILE "./myfifo"
#define MODE 0664 //用于设置文件的权限，0664代表着8进制写法，4是其他用户可读不可写
enum
{
    FIFO_CREATE_ERR = 1,
    FIFO_DELETE_ERR,
    FIFO_OPEN_ERR
};
class Init
{
public:
    Init()
    {
        //创建管道
        int n = mkfifo(FIFO_FILE,MODE);
        if(n == -1)
        {
            perror("mkfofi");
            exit(FIFO_CREATE_ERR);
        }
    }
    ~Init()
    {
         //删除命名管道
        int m = unlink(FIFO_FILE);
        if(m == -1)
        {
            perror("unlink");
            exit(FIFO_DELETE_ERR);
        }      
    }
};

log.hpp

#pragma noce
#include <stdarg.h>
// #include "common.hpp"
#include <iostream>
#include <stdio.h>
#include<string.h>//strerror(errno)头文件
#include<stdlib.h>
using namespace std;
#define Info        0
#define Debug       1
#define Warning     2
#define Error       3
#define Fatal       4 // 致命的
//打印方式
#define Screen      1 //屏幕
#define Onefile     2 //一个文件
#define Classfile   3 //多个文件
#define LogFile    "log.txt" 
class Log
{
public:
    Log()
    {
        printMehod = Screen;
        path = "./log/";
    }
    void Enable(int method)
    {
        printMehod = method;
    }
    string levelToString(int level)
    {
        switch (level)
        {
        case Info:
            return "Info";
        case Debug:
            return "Debug";
        case Warning:
            return "Warning";
        case Error:
            return "Error";
        case Fatal:
            return "Fatal";
        default:
            return "";
        }
        return "";
    }
    // void logmessage(int level, const char *format, ...)
    // {
    //     time_t t = time(nullptr);
    //     struct tm *ctime = localtime(&t);
    //     char leftbuffer[1024];
    //     snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d  %d:%d:%d]", levelToString(level).c_str(),
    //             ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday, ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
    //     va_list s;
    //     va_start(s, format);
    //     char rightbuffer[1024];
    //     vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);
    //     va_end(s);
    //     // 格式：默认部分+自定义部分
    //     char logtxt[1024 * 3];
    //     snprintf(logtxt, sizeof(logtxt), "%s  %s\n", leftbuffer, rightbuffer);
    //     //cout << logtxt << endl; // 暂时打印
    //     printLog(level, logtxt);
    // }
    void operator()(int level, const char* format, ...)
    {
        time_t t = time(nullptr);
        struct tm *ctime = localtime(&t);
        char leftbuffer[1024];
        snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%d-%d  %d:%d:%d]", levelToString(level).c_str(),
                ctime->tm_year + 1900, ctime->tm_mon + 1, ctime->tm_mday, ctime->tm_hour, ctime->tm_min, ctime->tm_sec);
        va_list s;
        va_start(s, format);
        char rightbuffer[1024];
        vsnprintf(rightbuffer, sizeof(rightbuffer), format, s);
        va_end(s);
        // 格式：默认部分+自定义部分
        char logtxt[1024 * 3];
        snprintf(logtxt, sizeof(logtxt), "%s  %s\n", leftbuffer, rightbuffer);
        //cout << logtxt << endl; // 暂时打印
        printLog(level, logtxt);
    }
    void printLog(int level, const string &logtxt)
    {
        switch(printMehod)
        {
            case Screen:
                cout<< logtxt <<endl;
            break;
            case Onefile:
                printOneFile(LogFile, logtxt);//"log.txt" 
            break;
            case Classfile:
                printClassFile(level, logtxt);
            break;
            default:
            break;
        }
    }
    void printOneFile(const string &logname, const string &logtxt)
    {
        //          "./log/" "log.txt"
        string _logname =path + logname;
        int fd = open(_logname.c_str(), O_WRONLY|O_CREAT|O_APPEND, 0666);
        if(fd < 0) return;
        write(fd, logtxt.c_str(), logtxt.size());
        close(fd);
    }
    void printClassFile(int level, const string &logtxt)
    {
        string filename = LogFile;//"log.txt" 
        filename += ".";//"log.txt." 
        filename += levelToString(level); //log.txt.Debug/Waring/Fatal
        printOneFile(filename, logtxt);
    }
    ~Log()
    {}
private:
    int printMehod;
    string path;
};

makefile

.PHONY:all
all:client server
server:server.cc
    g++ -o $@ $^ -g -std=c++11
    mkdir log
client:client.cc
    g++ -o $@ $^ -g -std=c++11
.PHONY:clean
clean:
    rm -f server client

server.cc

#include "common.hpp"
#include "log.hpp"
int main()
{
    //logmessage(Info, "hello");
    //创建管道
    Init init;
    Log log;
    //log.Enable(Onefile);
    log.Enable(Classfile);
    // //创建管道
    // int n = mkfifo(FIFO_FILE,MODE);
    // if(n == -1)
    // {
    //     perror("mkfofi");
    //     exit(FIFO_CREATE_ERR);
    // }
    // sleep(5);
    //打开管道
    int fd = open(FIFO_FILE,O_RDONLY);
    if(fd < 0)
    {
        //log.logmessage(Fatal, "error string:%s,error code:%d",strerror(errno), errno);
        //优化后
        log(Fatal, "error string:%s,error code:%d",strerror(errno), errno);
        exit(FIFO_OPEN_ERR);
    }
    // log.logmessage(Info, "server open file done,error string:%s,error code:%d",strerror(errno), errno);
    // log.logmessage(Warning, "server open file done,error string:%s,error code:%d",strerror(errno), errno);
    //优化后
    log(Info, "server open file done,error string:%s,error code:%d",strerror(errno), errno);
    log(Warning, "server open file done,error string:%s,error code:%d",strerror(errno), errno);
    //......
    //开始通信
    while(true)
    {
        char buffer[1024] = {0};
        int x = read(fd, buffer, sizeof(buffer));
        if(x > 0)
        {
            buffer[x] = 0;
            cout<< "client say# " << buffer <<endl;
        }
        else if(x == 0)
        {
            //log.logmessage(Debug, "sclient quit too!,error string:%s,error code:%d",strerror(errno), errno);
            //优化后
            log(Debug, "sclient quit too!,error string:%s,error code:%d",strerror(errno), errno);
            //cout<< "client quit too!\n" <<endl;
            break;
        }
        else break;
    }
    close(fd);
    // //删除命名管道
    // int m = unlink(FIFO_FILE);
    // if(n == -1)
    // {
    //     perror("unlink");
    //     exit(FIFO_DELETE_ERR);
    // }
    return 0;
}

标签： linux c++ c

本文转载自: https://blog.csdn.net/2401_83427936/article/details/142603367
版权归原作者 Ljw... 所有，如有侵权，请联系我们删除。

管道