【Linux】(32)详解命名管道 | 日志管理 | 进程池2.0

于 2024-08-09 14:59:31 发布
阅读量944 收藏 82
点赞数 92
分类专栏： Linux 文章标签： c++ 开发语言 linux 运维
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80171004/article/details/141061570
版权

目录

1. 介绍

2. 理解

3.运用

3.1 简易通信

makefile

comm.hpp

server.cc （服务端，读取显示）

client.cc (客户端，写入）

3.2 日志

log.hpp

1. 定义日志级别

2. 实现日志函数

可变参数

3. 日志输出管理

3.3 进程池 2.0

channel.hpp

tasks.hpp

main.cc

🏷️ 解释

1. 介绍

具有血缘关系的进程进行进程间通信，是匿名管道，如果毫不相关的进程进行通信呢？命名管道 mkfifo

eg. echo 和 cat 的实现，就是一种命名

🎢mkfifo() 函数

mkfifo() 函数用于创建一个FIFO（First In First Out）或者称为命名管道，它允许进程之间进行通信。下面是关于 mkfifo() 函数的详细介绍：man mkfifo

函数原型


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

int mkfifo(const char *pathname, mode_t mode);
  • pathname：要创建的命名管道的路径名。
  • mode：创建命名管道时设置的权限模式，通常以 8 进制表示，比如 0666。

返回值

  • 若成功，返回值为 0；若失败，返回值为 -1，并设置errno来指示错误类型。

功能

mkfifo() 函数的作用是在文件系统中创建一个特殊类型的文件，该文件在外观上类似于普通文件，但实际上是一个FIFO，用于进程之间的通信。这种通信方式是单向的，即数据写入FIFO的一端，可以从另一端读取出来，按照先进先出的顺序。

🎢创建命名管道

std::string fifoPath = "/tmp/my_named_pipe";  // 命名管道的路径名
mkfifo(fifoPath.c_str(), 0666); // 创建权限为0666的命名管道

🏷️注意事项

  • 路径名：确保要创建的命名管道路径名合法且没有重复。
  • 权限模式：根据实际需求设置合适的权限模式，确保可被需要访问该管道的进程所访问。
  • 错误处理：对 mkfifo() 函数的返回值进行适当的错误处理，根据具体的错误原因进行相应的处理和日志记录。

创建命名管道并处理错误的示例

#include <iostream>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <cerrno>
int main() {
    std::string fifoPath = "/tmp/my_named_pipe";  // 命名管道的路径名
    // 尝试创建命名管道
    if (mkfifo(fifoPath.c_str(), 0666) == -1) {
        // 检查错误类型
        if (errno == EEXIST) {
            std::cerr << "Named pipe already exists" << std::endl;
        } else {
            // 输出错误信息
            perror("Error creating named pipe");
        }
    } else {
        std::cout << "Named pipe created successfully" << std::endl;
    }
    return 0;
}

使用命名管道进行读写操作

在open后，可以通过 read() 或 write() 函数对其进行读写操作。

关闭命名管道

关闭命名管道是确保在进程使用完毕后释放相关资源的重要步骤。

#include <iostream>
#include <fcntl.h>
#include <unistd.h>
#include <cerrno>
int main() {
    int fd = open("/tmp/my_named_pipe", O_RDONLY);  // 以只读方式打开命名管道
    // 进行读取操作...
    // 关闭命名管道
    if (close(fd) == -1) {
        perror("Error closing named pipe");
    } else {
        std::cout << "Named pipe closed successfully" << std::endl;
    }
    return 0;
}

注意事项

  • 关闭顺序：如果有多个文件描述符指向同一个命名管道，需要依次关闭这些文件描述符，直到所有相关资源都得到释放。

通信方式

  • 单向通信：命名管道提供单向通信方式，一个进程写入，另一个进程读取。
  • 持久性：命名管道以文件形式存在于文件系统中，即使创建进程终止，管道仍然存在。
  • 阻塞和非阻塞：可以选择阻塞或非阻塞模式进行通信。

用法示例

进程 A 写入数据到命名管道

int fd = open("/tmp/my_named_pipe", O_WRONLY);  // 以只写方式打开命名管道
write(fd, "Hello, named pipe!", 18);  // 向管道中写入数据
close(fd);  // 关闭命名管道

进程 B 从命名管道读取数据

int fd = open("/tmp/my_named_pipe", O_RDONLY);  // 以只读方式打开命名管道
char buffer[50];
read(fd, buffer, 50);  // 从管道中读取数据
close(fd);  // 关闭命名管道

2. 理解

对创建的文件，进行只读/只写的 open

  1. 如果两个不同的进程，打开同一个文件的时候，在内核中，操作系统会维持几份呢？一份

还是这样的：

管道是文件缓冲区，不要进行刷盘！所以就有了内存级文件的存在

  1. 怎么打开同一个文件？为什么要打开同一个文件？

同路径下同一个文件名=路径+文件名 因为唯一性，就可以保证看到同一份资源了

3.运用

3.1 简易通信

makefile

.PHONY:all
all:server client

server:server.cc
	g++ -o $@ $^ -g -std=c++11
client:client.cc
	g++ -o $@ $^ -g -std=c++11

.PHONY:clean
clean:
	rm -f server client
  • .PHONY:all：这行声明 all 是一个伪目标。即使文件系统中存在一个名为 all 的文件，make all 命令也会执行与 all 相关的规则，而不是认为目标已经是最新的。
  • all:server client：这行定义了 all 伪目标的依赖，即 server 和 client。当运行 make all 时，Makefile 会首先尝试构建 server 和 client 目标。

comm.hpp

#ifndef COMM_HPP
#define COMM_HPP

#include <iostream>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <cstdlib>
#include <cstdio>

#define FIFO_FILE "/tmp/my_fifo"
#define FIFO_OPEN_ERR 1

#endif // COMM_HPP

server.cc （服务端，读取显示）

#include <iostream>
#include "comm.hpp"

using namespace std;

int main()
{
    // 创建命名管道文件
    if (mkfifo(FIFO_FILE, 0666) == -1)
    {
        if (errno != EEXIST)
        {
            perror("mkfifo");
            exit(FIFO_OPEN_ERR);
        }
    }

    // 打开管道
    int fd = open(FIFO_FILE, O_RDONLY);
    if (fd < 0)
    {
        perror("open");
        exit(FIFO_OPEN_ERR);
    }

    cout << "Server open file done" << endl;

    // 开始通信
    while (true)
    {
        char buffer[1024] = {0};
        int x = read(fd, buffer, sizeof(buffer) - 1);
        if (x > 0)
        {
            buffer[x] = 0;
            cout << "Client says: " << buffer << endl;
        }
        else if (x == 0)
        {
            cout << "Client quit, server will also quit." << endl;
            break;
        }
        else
        {
            perror("read");
            break;
        }
    }

    close(fd);
    return 0;
}

批注：

  1. 要等待写入方打开之后，自己才会打开文件，向后执行

client.cc (客户端，写入）

#include <iostream>
#include "comm.hpp"

using namespace std;

int main()
{
    // 打开管道
    int fd = open(FIFO_FILE, O_WRONLY);
    if (fd < 0)
    {
        perror("open");
        exit(FIFO_OPEN_ERR);
    }

    cout << "Client open file done" << endl;

    string line;
    while (true)
    {
        cout << "Please Enter: ";
        getline(cin, line);

        if (!line.empty())
        {
            write(fd, line.c_str(), line.size());
        }
    }
    close(fd);
    return 0;
}
write(fd, line.c_str(), line.size());  //将其字符流化

打开两个窗口，运行测试如下，成功~

接下来我们将来学习将错误日志化

3.2 日志

  1. 日志时间
  2. 日志等级
  • Info：常规消息
  • Warning：报错信息
  • Error：必要严重了，可能需要立即处理
  • Fatal：致命的
  • Debug：调试

    3.日志内容

    4.文件的名称和行号

实现一个简单的日志函数，在自己的代码中慢慢的引入日志

log.hpp

为了实现上述日志系统，我们可以按照以下步骤进行：

  1. 定义日志级别：定义常见的日志级别，如 Info、Warning、Error、Fatal、Debug。
  2. 实现日志函数：使用可变参数实现一个通用的日志函数，该函数能够记录不同级别的日志信息，并且包含时间戳、文件名和行号等信息。
  3. 日志输出管理：实现日志的输出方式，如输出到控制台或文件，支持按日志级别分类输出。
  4. 封装日志接口：提供一个简洁的接口，方便在代码中随时记录日志。

以下是代码实现示例：

1. 定义日志级别

在 log.hpp 中定义日志级别的枚举类型，并实现日志级别到字符串的映射。

// log.hpp
#pragma once

#include <string>
#include <ctime>
#include <iostream>
#include <fstream>
#include <cstdarg>
#include <cstdio>
#include <unistd.h>
#include <sys/types.h>

enum LogLevel {
    Info,
    Warning,
    Error,
    Fatal,
    Debug
};

inline std::string levelToString(LogLevel level) {
    switch (level) {
        case Info: return "INFO";
        case Warning: return "WARNING";
        case Error: return "ERROR";
        case Fatal: return "FATAL";
        case Debug: return "DEBUG";
        default: return "UNKNOWN";
    }
}

2. 实现日志函数

使用可变参数实现一个通用的日志函数 logMessage，能够记录日志级别、时间戳、文件名、行号，以及用户自定义的日志内容。

// log.hpp
#define SIZE 1024

void logMessage(LogLevel level, const char *filename, int line, const char *format, ...) {
    time_t t = time(nullptr);
    struct tm *ctime = localtime(&t);
    char leftbuffer[SIZE];
    snprintf(leftbuffer, sizeof(leftbuffer), "[%s][%d-%02d-%02d %02d:%02d:%02d][%s:%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,
             filename, line);

    char rightbuffer[SIZE];
    va_list args;
    va_start(args, format);
    vsnprintf(rightbuffer, sizeof(rightbuffer), format, args);
    va_end(args);

    char logtxt[SIZE * 2];
    snprintf(logtxt, sizeof(logtxt), "%s %s\n", leftbuffer, rightbuffer);

    printLog(level, logtxt);
}
可变参数
int sum(int n,...)  //之后会从右向左入栈
{
    va_list s;//char * 
    va_start(s,n);//s=&n+1 
}

sum函数是一个示例，它是一个可变参数函数，可以接受任意数量的整数参数，并返回它们的和。va_list类型用于遍历这些参数。

在sum函数中：

  1. int sum(int n,...)：声明了一个可变参数函数，它接受一个整数n和任意数量的整数参数。
  2. va_list s;：声明了一个va_list类型的变量s，用于遍历可变参数列表。
  3. va_start(s, n);：初始化va_list变量s，将可变参数列表的起始地址指向n之后的第一个参数。
  4. va_end(s);：清理va_list变量s，准备释放它占用的内存。

可变参数函数是C语言中非常强大的特性，它可以使代码更加通用和灵活。

// sum 函数的实例化
int sum(int n, ...) {
    va_list s;
    va_start(s, n);

    int result = 0;
    for (int i = 0; i <= n; i++) {
        result += va_arg(s, int);
    }

    va_end(s);
    return result;
}

// 示例使用 sum 函数
int main() {
    int sumResult = sum(3, 1, 2, 3);
    printf("The sum of the numbers is: %d\n", sumResult);
    return 0;
}

在这个例子中，定义了一个sum函数，它接受一个整数n和任意数量的整数参数。调用sum(3, 1, 2, 3)来实例化这个函数，它将计算1 + 2 + 3的和，并打印结果。

注意：sum函数的参数n是可选的，如果省略，则默认值为0，意味着它将接受任意数量的整数参数。在这个例子中，n的值为第一个数 3。

3. 日志输出管理

如何实现对多个日志分门别类的管理？

用'std::string _logname = path + logname' 都放到 log 中，实现管理

实现日志输出到控制台或文件的功能，支持按日志级别分类输出。

// log.hpp
enum PrintMethod {
    Screen,
    Onefile,
    Classfile
};

PrintMethod printMethod = Screen;
std::string path = "./";
std::string LogFile = "log.txt";

void printLog(LogLevel level, const std::string &logtxt) {
    switch (printMethod) {
        case Screen:
            std::cout << logtxt;
            break;
        case Onefile:
            printOneFile(LogFile, logtxt);
            break;
        case Classfile:
            printClassFile(level, logtxt);
            break;
        default:
            break;
    }
}

void printOneFile(const std::string &logname, const std::string &logtxt) {
    std::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(LogLevel level, const std::string &logtxt) {
    std::string filename = LogFile;
    filename += ".";
    filename += levelToString(level); // "log.txt.Debug/Warning/Fatal"
    printOneFile(filename, logtxt);
}

4. 封装日志接口

定义一个简洁的宏 LOG，方便在代码中使用日志功能。

// log.hpp
#define LOG(level, format, ...) logMessage(level, __FILE__, __LINE__, format, ##__VA_ARGS__)

5. 使用日志系统

在代码中可以使用 LOG 宏来记录日志信息，示例如下：

// main.cpp
#include "log.hpp"

int main() {
    LOG(Info, "Server started successfully.");
    LOG(Warning, "This is a warning message.");
    LOG(Error, "An error occurred: %s", "file not found");
    LOG(Fatal, "Fatal error, shutting down...");
    LOG(Debug, "Debugging info: variable x = %d", 42);

    // 更改日志输出方式为按级别分类
    printMethod = Classfile;
    LOG(Info, "Server started successfully with classified logs.");

    return 0;
}

6. 管理多级别日志

通过在 printClassFile 中使用 log.txt.Debug, log.txt.Warning, log.txt.Fatal 等文件名，可以自动将不同级别的日志写入不同的文件中，方便后续查找和调试。

🎢 日志管理总结

通过这种方式实现的日志系统能够灵活地处理不同级别的日志，并支持输出到控制台或文件中。通过使用 LOG 宏，日志功能可以很方便地集成到代码中，提供有效的调试和运行时信息支持。

后续还可以不断扩展和完善，例如添加日志轮转、异步日志、网络日志等高级功能，以适应更复杂的应用场景。对于错误不用再 printf，可以直接查日志啦

3.3 进程池 2.0

命名管道，能不能也设计成我们上一篇文章讲的进程池的样子呢？

使用命名管道（FIFO）实现一个进程池可以通过以下步骤完成：

  1. 创建命名管道：使用 mkfifo 创建两个命名管道，一个用于父进程向子进程发送任务，另一个用于子进程向父进程发送结果。
  2. 初始化进程池：创建子进程并为每个子进程分配命名管道。
  3. 父进程控制逻辑：父进程从标准输入获取任务，并通过命名管道将任务发送给子进程，然后读取子进程的结果。
  4. 子进程工作逻辑：子进程从命名管道读取任务，执行任务后将结果写回命名管道。

以下是使用命名管道实现进程池的代码：

channel.hpp

#pragma once

#include <string>
#include <vector>
#include <iostream>
#include <unistd.h>
#include <sys/wait.h>
#include <cassert>

class channel {
public:
    channel(const std::string &cmdfifo, const std::string &outfifo, int slaverid, const std::string &processname)
        : _cmdfifo(cmdfifo), _outfifo(outfifo), _slaverid(slaverid), _processname(processname) {}

public:
    std::string _cmdfifo;     // 发送任务的命名管道
    std::string _outfifo;     // 接收结果的命名管道
    pid_t _slaverid;          // 子进程的PID
    std::string _processname; // 子进程的名字 -- 方便我们打印日志
};

tasks.hpp

#pragma once

#include <iostream>
#include <vector>

typedef void (*task_t)();

void task1() {
    std::cout << "lol 刷新日志" << std::endl;
}

void task2() {
    std::cout << "lol 更新野区，刷新出来野怪" << std::endl;
}

void task3() {
    std::cout << "lol 检测软件是否更新,如果需要，就提示用户" << std::endl;
}

void task4() {
    std::cout << "lol 用户释放技能，更新用的血量和蓝量" << std::endl;
}

void LoadTask(std::vector<task_t> *tasks) {
    tasks->push_back(task1);
    tasks->push_back(task2);
    tasks->push_back(task3);
    tasks->push_back(task4);
}

main.cc

#include <iostream>
#include <vector>
#include <string>
#include <unistd.h>
#include <sys/wait.h>
#include <fcntl.h>
#include <cstdlib>
#include <ctime>
#include <sstream>
#include "channel.hpp"
#include "tasks.hpp"

void slaver(const std::vector<task_t> &tasks, const std::string &cmdfifo, const std::string &outfifo) {
    int cmdfd = open(cmdfifo.c_str(), O_RDONLY);
    int outfd = open(outfifo.c_str(), O_WRONLY);

    while (true) {
        int cmdcode = 0;
        int n = read(cmdfd, &cmdcode, sizeof(int)); // 从命令管道读取命令码
        if (n == sizeof(int)) {
            // 使用 stringstream 重定向 std::cout 到一个字符串
            std::ostringstream oss;
            std::streambuf *oldCoutStreamBuf = std::cout.rdbuf();
            std::cout.rdbuf(oss.rdbuf());

            if (cmdcode >= 0 && cmdcode < tasks.size()) {
                tasks[cmdcode]();
            }

            std::cout.rdbuf(oldCoutStreamBuf); // 恢复 std::cout 的重定向

            std::string output = oss.str();
            write(outfd, output.c_str(), output.size()); // 写到输出管道中
        }
        if (n == 0) break; // 父进程关闭写端，子进程退出
    }

    close(cmdfd);
    close(outfd);
}

void InitProcessPool(std::vector<channel> *channels, const std::vector<task_t> &tasks, int processnum) {
    for (int i = 0; i < processnum; i++) {
        std::string cmdfifo = "/tmp/cmdfifo_" + std::to_string(i);
        std::string outfifo = "/tmp/outfifo_" + std::to_string(i);
        mkfifo(cmdfifo.c_str(), 0666);
        mkfifo(outfifo.c_str(), 0666);

        pid_t id = fork();
        if (id == 0) { // child process
            slaver(tasks, cmdfifo, outfifo);
            exit(0);
        } else { // parent process
            std::string name = "process-" + std::to_string(i);
            channels->push_back(channel(cmdfifo, outfifo, id, name));
            sleep(1);
        }
    }
}

void Menu() {
    std::cout << "################################################" << std::endl;
    std::cout << "# 1. 刷新日志             2. 刷新出来野怪        #" << std::endl;
    std::cout << "# 3. 检测软件是否更新      4. 更新用的血量和蓝量  #" << std::endl;
    std::cout << "#                         0. 退出               #" << std::endl;
    std::cout << "#################################################" << std::endl;
}

void ctrlSlaver(const std::vector<channel> &channels, const std::vector<task_t> &tasks) {
    int which = 0;
    while (true) {
        int select = 0;
        Menu();
        std::cout << "Please Enter@ ";
        std::cin >> select;

        if (select <= 0 || select >= 5) break;

        int cmdcode = select - 1;

        int cmdfd = open(channels[which]._cmdfifo.c_str(), O_WRONLY);
        write(cmdfd, &cmdcode, sizeof(cmdcode));
        close(cmdfd);

        int outfd = open(channels[which]._outfifo.c_str(), O_RDONLY);
        char buffer[256];
        int n = read(outfd, buffer, sizeof(buffer) - 1);
        if (n > 0) {
            buffer[n] = '\0';
            std::cout << buffer;
        }
        close(outfd);

        which++;
        which %= channels.size();
    }
}

void QuitProcess(const std::vector<channel> &channels) {
    for (const auto &c : channels) {
        unlink(c._cmdfifo.c_str());
        unlink(c._outfifo.c_str());
        waitpid(c._slaverid, NULL, 0);
    }
}

int main() {
    srand(time(nullptr) ^ getpid() ^ 1023);

    std::vector<task_t> tasks;
    LoadTask(&tasks);

    int processnum = 4;
    std::vector<channel> channels;
    InitProcessPool(&channels, tasks, processnum);

    ctrlSlaver(channels, tasks);

    QuitProcess(channels);

    return 0;
}

🏷️ 解释

  1. channel 类：
    • channel 类保存了命令和输出的命名管道文件路径 _cmdfifo 和 _outfifo，以及子进程的 PID 和名字。
  1. slaver 函数：
    • 子进程在 slaver 函数中运行，从命令管道读取任务码，执行任务并将结果写入输出管道。
  1. InitProcessPool 函数：
    • 创建子进程并为每个子进程分配命令和输出的命名管道。
    • 使用 mkfifo 创建命名管道，并使用 fork 创建子进程。
  1. ctrlSlaver 函数：
    • 父进程从标准输入获取任务码，并通过命令管道发送给子进程。
    • 通过输出管道读取子进程的结果并打印出来。
  1. QuitProcess 函数：
    • 删除所有命名管道，并等待所有子进程退出。

通过这些步骤，父进程就可以通过命名管道与子进程通信，并实现一个简单的进程池啦

lvy¯
关注
  • 92
    点赞
  • 踩
  • 82
    收藏
    觉得还不错? 一键收藏
  • 69
    评论
专栏目录
Linux 日志服务与日志管理详解
悦分享
01-08 803
在Linux系统中，系统日志一般都保存在/var/log/目录下。如下所示： 具体介绍一下这上面的主要日志文件：/var/run/utmp/var/log/messages系统总日志：/var/log/secure登录日志：/var/log/dmesg系统启动日志： /var/log/yum.log日志：说明：不能用vim编辑器查看的日志文件示例。 为什么有些日志文件不能使用vim编辑器查看？是因为这些日志文件中的内容，记录的是重要系统资源的日志，与系统安全有关，不能让你修改，要确保数据的准确性
Linux 私房菜 笔记（完结）
qq_57065913的博客
03-14 3605
目录 第一章 计算机概论 第一章 计算机概论
linux系统调用和内存管理以及栈帧
SurpriseDPD的博客
09-16 910
一. linux编程笔记和C++编程笔记 0. terminal操作快捷键等 终端的设置项 对终端的设置主要包括：配置文件首选项和键盘快捷键的设置。选择“编辑” 菜单进入相关的设置。 创建终端的标签页 1 通过 Ctrl+Shift+T 快捷键创建新标签页。 2 选择 “文件” 菜单 -> 选择“打开标签页” 选项。 3 在终端中，单击鼠标右键（或按下键盘上的Application 键），选择 “打开标签页” 选项。 终端默认的常用快捷键 快捷键 描述 Ctrl+Alt+T 启动终端
嵌入式Linux八股（二）——Linux
qq_46150894的博客
04-21 1159
Linux 静态库和动态库 | 爱编程的大丙 (subingwen.cn)静态库ar rcs命令用于创建静态库（archive），将一组目标文件（.o文件）打包成一个静态库文件（.a文件）。例如，如果要将一组目标文件file1.ofile2.o和file3.o打包成一个名为的静态库，可以使用以下命令：这将创建一个名为的静态库文件，并将file1.ofile2.o和file3.o这三个目标文件添加到该静态库中。在Linux中静态库以lib作为前缀, 以.a。
Linux
qq_40822132的博客
12-28 679
操作系统，英语Operating System简称为OS。说道操作系统就需要先讲一讲Unix，UNIX操作系统，是一个强大的多用户、多任务操作系统，支持多种处理器架构，按照操作系统的分类，属于分时操作系统，最早由KenThompson、Dennis Ritchie和Douglas McIlroy于1969年在AT&T的贝尔实验室开发。而linux就是一款类Unix系统。
（完整版）2022大厂Java八股文面试题库｜附答案
uuqaz的博客
05-05 1万+
Java基础 说下面向对象四大特性 Java语言有些特点 什么是Java程序的主类？应用程序和小程序的主类有何不同？ 访问修饰符public,private,protected,以及不写（默认）时的区别？ float f=3.4;是否正确？ Java有没有goto？ &和&&的区别？ Math.round(11.5) 等于多少？Math.round(-11.5)等于多少？ 用最有效率的方法计算2乘以8？ 什么是Java注释 Java有哪些数据类型 final
centos7:在linux世界里,一切皆文件
weixin_42856413的博客
05-13 3488
目录附录：1.您在 /var/spool/mail/root 中有新邮件提示处理2.几种清屏方式3.Linux下修改PATH路径4.学习linux阶段:5.X系列工具Xshellxshell传输文件Xftp5安装GNOME桌面环境总览Linux 的主要的发行版Linux 的目录结构vi 和 vim 编辑器vi 和 vim 的三种常见模式快捷键的使用案例命令系统命令查看系统信息防火墙操作(修改完重启才会生效)firewalld中的zone网络相关命令开机、重启和用户登录注销用户登录和注销用户管理错误bash-
从零基础入门Linux系统
ॢ小天ꦿ᭄ﻬଓ的博客
07-30 6092
从零基础入门Linux系统 目录 第一章：Linux简介 1 一、Linux是什么 1 二、Unix和Linux的发展史 1 三、开源软件介绍 4 四、Linux的应用场景 5 第二章：Linux安装和部署 8 一、 虚拟机的安装和使用 8 二、Linux的分区相关原理 16 三、CentOS 6.8的安装流程 20 四、CentOS 7.5 的安装流程 35 五、远程管理Linux操作系统 43 第三章：给初学者的Linux服务器管理建议 44 一、学习Linux的注意事项 44 二、服务器管理建议 46
Logback各Appender详解及配置
热门推荐
tianyaleixiaowu的专栏
06-16 4万+
转载自：http://blog.csdn.net/doraemon_wu/article/details/51972261 Logback将执行日志事件输出的组件称为Appender，实现的Appender必须继承 ch.qos.logback.core.Appender 接口 接口如下： package ch.qos.logback.core; import ch
linux 命名管道实例详解
09-15
【命名管道详解】 命名管道，也称为FIFO（First In First Out），是Linux操作系统中实现进程间通信（IPC，Inter-Process Communication）的一种机制。与匿名管道不同，命名管道提供了路径名，使其能够像普通文件...
Linux日志管理详解.docx
12-16
Linux日志管理详解 Linux日志管理是指对Linux系统中各种日志文件的管理和分析，以便更好地了解系统的运行状态、检测和解决问题。该过程包括日志文件的查看、分析和管理，旨在提高系统的安全性和可靠性。 日志连接...
Linux日志管理五大命令详解.pdf
11-16
Linux日志管理五大命令详解.pdf
详解Python进程间通信之命名管道
12-25
通常启动进程创建一个管道，然后这个进程创建一个或者多个进程子进程接受管道信息，由于管道是单向通信，所以经常需要创建两个管道来实现双向通信。 命名管道是对传统管道的扩展，默认的管道是匿名管道，只在程序...
linuxptp2.0详解.txt
06-02
文件是开源软件linuxptp2.0的解释信息，包括文件功能简介，处理逻辑介绍，术语介绍等等，如果你需要理解1588协议栈linuxptp2.0的实现逻辑，该文档是很好的参考文档，能帮你最快的理解代码；文档绝对原创，全网独一份...
linux 匿名管道实例详解
08-30
Linux 匿名管道实例详解是 Linux 系统中的一种进程间通信方式。匿名管道是一种半双工通信方式，即只能实现单向通信。匿名管道的通信是通过 pipe 函数建立的，在内核中开辟了一块缓冲区（称为管道），用于进程间的...
MySQL日志管理详解
02-01
在对应的数据目录中，以主机名+.err命名的文件，错误日志记录的信息类型：记录了服务器运行中产生的错误信息记录了服务在启动和停止是所产生的信息在从服务器上如果启动了复制进程的时候，复制进程的信息也会被记录...
Linux进程通信：命名管道FIFO小结.doc
最新发布
04-30
### Linux进程通信：命名管道FIFO详解 #### 一、命名管道(FIFO)概述 命名管道，也称为FIFO(File-In-First-Out)，是Linux系统中的一种进程间通信(IPC)机制。它允许不同进程之间通过共享文件系统来进行数据交换。与...
C++命名管道详解及简单案例（基于VS2013）
01-04
C++命名管道是一种实现进程间通信（IPC，Inter-Process Communication）的方式，它允许不同的进程之间交换数据。本篇文章将详细讲解C++中如何使用命名管道，并提供一个基于Visual Studio 2013的简单案例。 首先，...
评论 69
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值