[linux仓库]告别空洞理论！手写一个高性能日志模块，为线程池实战铺路[线程·捌]

最新推荐文章于 2025-12-05 20:50:35 发布
原创 最新推荐文章于 2025-12-05 20:50:35 发布 · 1.2k 阅读 · 77 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#开发语言 #linux #日志 #策略模式 #池化技术

🌟 各位看官好，我是！

🌍 Linux == Linux is not Unix ！

🚀 为了给线程池做铺垫,需要手写日志模块方便调试,并引入所谓的池化技术以及日志所采用的策略模式。

👍 如果觉得这篇文章有帮助，欢迎您一键三连，分享更多人哦！

目录

书接上文

谈兵先识器：在构建线程池之前，我们先聊聊“池化技术”

什么是池化技术？—— 一种“未雨绸缪”的智慧

为什么要池化？—— 因为“从零创建”的代价远比你想象的要高

日志与策略模式

日志认识

代码编写

日志等级

时间戳

文件名和行号

刷新策略

激活策略

日志内容

总结

附源码

书接上文

谈兵先识器：在构建线程池之前，我们先聊聊“池化技术”

书接上文，在我们掌握了线程控制、锁以及条件变量这些并发编程的利器之后，我们终于可以着手设计并实现一个真正实用的组件——线程池。

但在我们敲下第一行代码之前，有一个更宏观、更具指导性的思想需要先深入理解，那就是“池化技术”（Pooling Technology）。这不仅是线程池的核心，也是构建几乎所有高性能后台服务的基石。

什么是池化技术？—— 一种“未雨绸缪”的智慧

让我们先抛开代码，来看一个生活中的例子：

想象一下，你经营着一家非常火爆的网约车公司。每当有乘客下单时，你才开始打电话招募司机、给他们注册、分配车辆。等这一套流程走完，乘客早已不耐烦地取消了订单。

聪明的做法是什么？你提前招募并培训好一批司机，让他们在几个热门地段的“司机站”里随时待命。订单一来，你立刻从站里派一位空闲的司机出发。任务完成后，司机不是解雇回家，而是返回站点继续等待下一个订单。

这个“司机站”就是“池”。池化技术的核心思想就是：将一批昂贵的、需要频繁使用的资源预先创建好并统一管理起来，当需要时直接从“池”中获取，用完后不是销毁，而是归还给“池”，以供后续复用。

为什么要池化？—— 因为“从零创建”的代价远比你想象的要高

正如下图提到的，池化技术旨在“减少底层重复工作”。

然而，如果我们直接一头扎进复杂的并发代码中，就好比在没有地图和手电筒的情况下探索一个漆黑的洞穴——我们很快就会迷失方向。

这个“手电筒”和“地图”，就是日志系统。在多线程环境中，断点调试（GDB）的作用会因为线程间的时序和调度问题而大打折扣。一个可靠的、能够记录关键信息和错误状态的日志系统，是我们分析、调试和监控我们未来线程池运行状态的生命线。

但在动手写日志系统之前，我们先要学习一种能让它变得无比灵活和强大的设计模式——策略模式 (Strategy Pattern)。

日志与策略模式

为了讲解日志模式,这里不得不提到设计模式,那么什么是设计模式呢?

IT⾏业这么⽕, 涌⼊的⼈很多. 俗话说林⼦⼤了啥⻦都有. ⼤佬和菜鸡们两极分化的越来越严重. 为了让菜鸡们不太拖⼤佬的后腿, 于是⼤佬们针对⼀些经典的常⻅的场景, 给定了⼀些对应的解决⽅案,这个就是设计模式.(可是我怎么从来没有看到啊?在腾讯、阿里、谷歌等大厂中公布了一些开源的日志设计,等会在编写过程中会使用到谷歌是如何搭建日志框架,如何进行设计的. )

日志认识

计算机中的⽇志是记录系统和软件运⾏中发⽣事件的⽂件，主要作⽤是监控运⾏状态、记录异常信息，帮助快速定位问题并⽀持程序员进⾏问题修复。它是系统维护、故障排查和安全管理的重要工具。

那么一个日志有哪些必要的指标呢?格式应该是怎样的呢?

必要:

  1. 时间戳(记录出现问题时的时间)
  2. 日志内容(我报的内容是啥错?)
  3. 日志等级(这个问题是正常输出的;是申请失败,不影响运行;还是引起错误,可以重新重启的呢?)
  • DEBUG,做测试
  • INFO,正常输出
  • WARING:申请失败,不影响运行
  • ERROR:引起错误,可以重新重启
  • FATAL:不一定是正常结束,需要排查

可选:

  1. 文件名和行号
  2. 进程，线程相关id信息等

日志格式:

[可读性很好的时间] [⽇志等级] [进程pid] [打印对应⽇志的⽂件名][⾏号] - 消息内容，⽀持可变参数
[2024-08-04 12:27:03] [DEBUG] [202938] [main.cc] [16] - hello world
[2024-08-04 12:27:03] [DEBUG] [202938] [main.cc] [17] - hello world
[2024-08-04 12:27:03] [DEBUG] [202938] [main.cc] [18] - hello world
[2024-08-04 12:27:03] [DEBUG] [202938] [main.cc] [20] - hello world
[2024-08-04 12:27:03] [DEBUG] [202938] [main.cc] [21] - hello world
[2024-08-04 12:27:03] [WARNING] [202938] [main.cc] [23] - hello world

代码编写

进行日志格式代码设计的时候,需要注意以下两个核心问题:

  1. 刷新策略 --> 是向显示器刷新,还是文件刷新,还是网络等等呢?
  2. 需要刷新那么就一定得构建一条完整的日志,而这需要日志格式的支持.

日志等级

// 规定出场景的日志等级
enum class LogLevel
{
    DEBUG,
    INFO,
    WARNING,
    ERROR,
    FATAL
};

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

这里通过枚举分为5个日志等级,那为什么还需要Level2String这个函数呢?

DEBUG 等在编译后就是数字,为了将枚举值转换为人类可读的字符串,因此用Level2String函数将数字转为字符串.

时间戳

系统提供一个获取时间戳的系统调用:time_t time(time_t *_Nullable tloc);

  • tloc指的是时区,默认为nullptr即可.
  • time_t是什么呢? long int 一个长整数
    // 1. 获取时间戳
    time_t currtime = time(nullptr);

可是时间戳我们看不懂啊?同样需要转为人类看的懂的时间,提供了一套函数把时间戳转换为人类看的懂的语言

struct tm *localtime(const time_t *timep);
struct tm *localtime_r(const time_t *restrict timep, struct tm *restrict result);

  • timep 是输入参数;
  • restrict result 是输出参数.

这两个函数都将一个指向 time_t 类型（通常是自 1970-01-01 00:00:00 +0000 (UTC) 以来的秒数）的指针作为输入，并将其转换为本地时间（根据系统设定的时区进行计算），然后将转换后的结果填充到一个 struct tm 结构体中。

带_r是什么意思呢?凡是带_r的代表该函数是可被重入的.

struct tm {
           int         tm_sec;    /* Seconds          [0, 60] */
           int         tm_min;    /* Minutes          [0, 59] */
           int         tm_hour;   /* Hour             [0, 23] */
           int         tm_mday;   /* Day of the month [1, 31] */
           int         tm_mon;    /* Month            [0, 11]  (January = 0) */
           int         tm_year;   /* Year minus 1900 */
           int         tm_wday;   /* Day of the week  [0, 6]   (Sunday = 0) */
           int         tm_yday;   /* Day of the year  [0, 365] (Jan/01 = 0) */
           int         tm_isdst;  /* Daylight savings flag */

           long        tm_gmtoff; /* Seconds East of UTC */
           const char *tm_zone;   /* Timezone abbreviation */
       };

    // 2. 如何把时间戳转换成为20XX-08-04 12:27:03
    struct tm currtm;
    localtime_r(&currtime, &currtm);

    // 3. 转换成为字符串 -- dubug?
    char timebuffer[64];
    snprintf(timebuffer, sizeof(timebuffer), "%4d-%02d-%02d %02d:%02d:%02d",
             currtm.tm_year + 1900,
             currtm.tm_mon + 1,
             currtm.tm_mday,
             currtm.tm_hour,
             currtm.tm_min,
             currtm.tm_sec);

文件名和行号

#define LOG(level) logger(level, __FILE__, __LINE__)

  • __FILE__：自动替换为当前源代码文件的文件名（字符串类型）；
  • __LINE__：自动替换为当前代码所在的行号（整数类型）。

刷新策略

假设这时已经拿到了一条完整的日志,而这条日志是向显示器刷新还是向文件刷新还是网络刷新?由我们进行选择,因此我们必须要写一个关于刷新策略的类.这里通过定义:

  • LogStrategy的基类 -- 定义统一的日志行为,定义所有日志输出策略必须实现的核心方法，确保不同输出方式的接口一致性。
// 1. 刷新的问题 -- 假设我们已经有了一条完整的日志，string->设备(显示器，文件)
// 基类方法
class LogStrategy
{
public:
    virtual ~LogStrategy() = default;
    virtual void SyncLog(const std::string &logmessage) = 0;
};
  • ConsoleLogStrategy—— 控制台日志输出

将来我们的日志可以被多种线程访问的,如果 刷新测量是往显示器做刷新,一旦刷新往显示器上打,显示器作为临界资源就需要被保护起来,因此需要进行加锁啊!

// 显示器刷新
class ConsoleLogStrategy : public LogStrategy
{
public:
    ~ConsoleLogStrategy()
    {
    }
    void SyncLog(const std::string &logmessage) override
    {
        {
            LockGuard lockguard(&_lock);
            std::cout << logmessage << std::endl;
        }
    }

private:
    Mutex _lock;
};
  • FileLogStrategy—— 文件日志输出

当刷新策略设定为向文件刷新日志时，自然会想到对日志信息按等级分类 —— 比如哪些属于 INFO 级、哪些是 ERROR 级、哪些又该归为 FATAL 级，再将不同等级的日志分别写入对应文件中。但随之会遇到一个问题：若把这些日志文件都直接放在当前目录下，随着时间推移，文件会越积越多，整个目录会显得杂乱无章。所以很自然地会考虑创建一个专门的 log 目录，用来统一存放这些日志文件。可这里又有了新的疑问：我们目前只学过用 mkdir 指令来创建目录，却还没接触过通过系统调用来创建目录的方法，那该如何通过系统调用实现 log 目录的创建呢？

int mkdir(const char *pathname, mode_t mode);

这里并不用上面的系统调用,提供C++17的文件操作 --> 判断目录是否存在,不存在就创建.

std::filesystem::exists(_dir_path_name); //检查指定路径对应的目录或文件是否存在

std::filesystem::create_directories(_dir_path_name); //用于递归创建目录
const std::string logdefaultdir = "log";
const static std::string logfilename = "test.log";

// 文件刷新
class FileLogStrategy : public LogStrategy
{
public:
    FileLogStrategy(const std::string &dir = logdefaultdir,
                    const std::string filename = logfilename)
        : _dir_path_name(dir), _filename(filename)
    {
        LockGuard lockguard(&_lock);
        if (std::filesystem::exists(_dir_path_name))
        {
            return;
        }
// 可能父目录不允许创建等问题,所以需要try一下
        try
        {
            std::filesystem::create_directories(_dir_path_name);
        }
        catch (const std::filesystem::filesystem_error &e)
        {
            std::cerr << e.what() << "\r\n";
        }
    }
    void SyncLog(const std::string &logmessage) override
    {
        {
            LockGuard lockguard(&_lock);
            std::string target = _dir_path_name;
            target += "/";
            target += _filename;

            std::ofstream out(target.c_str(), std::ios::app); // append
            if (!out.is_open())
            {
                return;
            }
            out << logmessage << "\n"; // out.write
            out.close();
        }
    }

    ~FileLogStrategy()
    {
    }

private:
    std::string _dir_path_name; // log
    std::string _filename;      // hello.log => log/hello.log
    Mutex _lock;
};

// 网络刷新
激活策略
class Logger
{
public:
    Logger()
    {
    }
    void EnableConsoleLogStrategy()
    {
        _strategy = std::make_unique<ConsoleLogStrategy>();
    }
    void EnableFileLogStrategy()
    {
        _strategy = std::make_unique<FileLogStrategy>();
    }
    ~Logger()
    {
    }

private:
    std::unique_ptr<LogStrategy> _strategy;
};

日志内容

实现日志信息的方法有很多种,这里介绍一种谷歌实现日志的十分巧妙的方法:

首先定义了一个内部类Logger,为了能支持将一条日志信息刷新出去,将外部类的刷新策略也带进内部类里,这样一旦形成日志信息,就可以把数据刷新出去.

    class LogMessage
    {
    private:
        std::string _curr_time; // 日志时间
        LogLevel _level; // 日志等级
        pid_t _pid; // 进程pid
        std::string _filename;
        int _line;

        std::string _loginfo; // 一条合并完成的，完整的日志信息
        Logger &_logger; // 提供刷新策略的具体做法
    };
    LOG(LogLevel::ERROR) << "hello world" << ", 3.14 " << 123;

LogMessage的构造如下:

        LogMessage(LogLevel level, std::string &filename, int line, Logger &logger)
        : _curr_time(GetCurrentTime()),
          _level(level),
          _pid(getpid()),
          _filename(filename),
          _line(line),
          _logger(logger)
        {
            std::stringstream ss;
            ss << "[" << _curr_time << "] "
               << "[" << Level2String(_level) << "] "
               << "[" << _pid << "] "
               << "[" << _filename << "] "
               << "[" << _line << "]"
               <<  " - ";
            _loginfo = ss.str();
        }

需要注意的是日志内容会面临参数不一定,类型也不一定的问题啊!那该怎样把一条完整的内容拿到呢?这里在内部类对<<做重载

        template<typename T>
        LogMessage& operator << (const T &info)
        {
            std::stringstream ss;
            ss << info;
            _loginfo += ss.str();
            return *this;
        }

可是如何才能调用内部类的构造和<<运算符重载呢?这无疑成为了一个难点:

谷歌采用一个非常精妙的方法:在外部类定义一个()的运算符重载

    LogMessage operator()(LogLevel level, std::string filename, int line)
    {
        return LogMessage(level, filename, line, *this);
    }

是啊总算可以串起来了:

LOG(LogLevel::ERROR) << "hello world" << ", 3.14 " << 123;

会被宏替换为logger(LogLevel::ERROR, __FILE__, __LINE__) << "hello world" << ", 3.14 " << 123;

接着logger(LogLevel::ERROR, __FILE__, __LINE__)会调用()运算符重载,故意拷贝,形成LogMessage临时对象,拿到了除日志内容的相关信息,需要注意的是()重载返回的是一个临时对象啊 ! 后续在被<<时，会被持续引⽤，直到没有<<，_loginfo已经有一条完整的信息了.此时还差一口气没有补上,如何把这条日志信息刷新出去呢?由于该临时对象没被<<时,生命周期结束了,此时会被析构啊!那么我们在析构函数这将信息刷新出去不就行了?

        ~LogMessage()
        {
            if(_logger._strategy)
            {
                _logger._strategy->SyncLog(_loginfo);
            }
        }

总结

本文介绍了Linux日志系统的设计与实现，重点讲解了日志格式设计和刷新策略。主要内容包括：

  1. 日志等级划分（DEBUG/INFO/WARNING/ERROR/FATAL）及对应字符串转换；
  2. 时间戳获取与格式化；
  3. 基于策略模式的日志输出方式（控制台输出、文件输出等）；
  4. 采用Google风格的日志内容构建方法，通过运算符重载实现灵活的日志信息拼接。文章还详细阐述了文件日志策略中的目录创建、线程安全处理等关键技术点，最终实现了一个支持多级别、多输出方式的灵活日志系统框架。

附源码

#pragma once

#include <iostream>
#include <string>
#include <filesystem> // C++17 文件操作
#include <fstream>
#include <ctime>
#include <unistd.h>
#include <memory>
#include <sstream>
#include "Mutex.hpp"

// 1.将一条日志信息进行分等级
// 2.获得时间戳,转换为年月日
// 3.选择刷新策略
// 4.把消息带出去

// 规定出场景的日志等级
enum class LogLevel
{
    DEBUG,
    INFO,
    WARNING,
    ERROR,
    FATAL
};

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

// 20XX-08-04 12:27:03
std::string GetCurrentTime()
{
    // 1. 获取时间戳
    time_t currtime = time(nullptr);

    // 2. 如何把时间戳转换成为20XX-08-04 12:27:03
    struct tm currtm;
    localtime_r(&currtime, &currtm);

    // 3. 转换成为字符串 -- dubug?
    char timebuffer[64];
    snprintf(timebuffer, sizeof(timebuffer), "%4d-%02d-%02d %02d:%02d:%02d",
             currtm.tm_year + 1900,
             currtm.tm_mon + 1,
             currtm.tm_mday,
             currtm.tm_hour,
             currtm.tm_min,
             currtm.tm_sec);

    return timebuffer;
}

///////////////////////////////////////////////////////////////////
// 1. 刷新的问题 -- 假设我们已经有了一条完整的日志，string->设备(显示器，文件)
// 基类方法
class LogStrategy
{
public:
    virtual ~LogStrategy() = default;
    virtual void SyncLog(const std::string &logmessage) = 0;
};

// 显示器刷新
class ConsoleLogStrategy : public LogStrategy
{
public:
    ~ConsoleLogStrategy()
    {
    }
    void SyncLog(const std::string &logmessage) override
    {
        {
            LockGuard lockguard(&_lock);
            std::cout << logmessage << std::endl;
        }
    }

private:
    Mutex _lock;
};

const std::string logdefaultdir = "log";
const static std::string logfilename = "test.log";

// 文件刷新
class FileLogStrategy : public LogStrategy
{
public:
    FileLogStrategy(const std::string &dir = logdefaultdir,
                    const std::string filename = logfilename)
        : _dir_path_name(dir), _filename(filename)
    {
        LockGuard lockguard(&_lock);
        if (std::filesystem::exists(_dir_path_name))
        {
            return;
        }
        try
        {
            std::filesystem::create_directories(_dir_path_name);
        }
        catch (const std::filesystem::filesystem_error &e)
        {
            std::cerr << e.what() << "\r\n";
        }
    }
    void SyncLog(const std::string &logmessage) override
    {
        {
            LockGuard lockguard(&_lock);
            std::string target = _dir_path_name;
            target += "/";
            target += _filename;

            std::ofstream out(target.c_str(), std::ios::app); // append
            if (!out.is_open())
            {
                return;
            }
            out << logmessage << "\n"; // out.write
            out.close();
        }
    }

    ~FileLogStrategy()
    {
    }

private:
    std::string _dir_path_name; // log
    std::string _filename;      // hello.log => log/hello.log
    Mutex _lock;
};

// 网络刷新

////////////////////////////////////////////////////////

// 1. 定制刷新策略
// 2. 构建完整的日志
class Logger
{
public:
    Logger()
    {
    }
    void EnableConsoleLogStrategy()
    {
        _strategy = std::make_unique<ConsoleLogStrategy>();
    }
    void EnableFileLogStrategy()
    {
        _strategy = std::make_unique<FileLogStrategy>();
    }
    // 形成一条完整日志的方式
    class LogMessage
    {
    public:
        LogMessage(LogLevel level, std::string &filename, int line, Logger &logger)
        : _curr_time(GetCurrentTime()),
          _level(level),
          _pid(getpid()),
          _filename(filename),
          _line(line),
          _logger(logger)
        {
            std::stringstream ss;
            ss << "[" << _curr_time << "] "
               << "[" << Level2String(_level) << "] "
               << "[" << _pid << "] "
               << "[" << _filename << "] "
               << "[" << _line << "]"
               <<  " - ";
            _loginfo = ss.str();
        }
        template<typename T>
        LogMessage& operator << (const T &info)
        {
            std::stringstream ss;
            ss << info;
            _loginfo += ss.str();
            return *this;
        }

        ~LogMessage()
        {
            if(_logger._strategy)
            {
                _logger._strategy->SyncLog(_loginfo);
            }
        }
    private:
        std::string _curr_time; // 日志时间
        LogLevel _level; // 日志等级
        pid_t _pid; // 进程pid
        std::string _filename;
        int _line;

        std::string _loginfo; // 一条合并完成的，完整的日志信息
        Logger &_logger; // 提供刷新策略的具体做法
    };
    LogMessage operator()(LogLevel level, std::string filename, int line)
    {
        return LogMessage(level, filename, line, *this);
    } 
    ~Logger()
    {
    }

private:
    std::unique_ptr<LogStrategy> _strategy;
};

Logger logger;

#define LOG(level) logger(level, __FILE__, __LINE__)
#define EnableConsoleLogStrategy() logger.EnableConsoleLogStrategy()
#define EnableFileLogStrategy() logger.EnableFileLogStrategy()

【linuxC语言】空洞文件
m0_62599305的博客
05-01 2633
在 Linux 系统编程中，空洞文件是一种特殊类型的文件，它包含了逻辑上的空洞，也就是说文件中的某些部分并没有实际写入数据。尽管文件在逻辑上可能非常大，但实际上只占用了磁盘上的少量空间。空洞文件在实际应用中有许多有趣的用途，可以帮助节省磁盘空间、加快文件传输速度以及进行性能测试等。本文将探讨空洞文件的定义、创建方法以及其在 Linux 系统编程中的应用。空洞文件是一种在磁盘上占用空间但实际内容中有一部分为零字节的文件。
linux使用gpio开一个线程,LINUX的gpio_request_one作用
weixin_36028342的博客
05-10 2542
一直习惯使用gpio_request来申请一个GPIO，然后用gpio_direction_input、gpio_direction_output等函数来配置对应的GPIO，用gpio_free来释放申请。后来看到别人也会用gpio_request_one来申请和配置一个GPIO，然后就去看看看这个接口的实现，发现这个函数就是对一个GPIO的申请和配置的组合而已。但是看到这个函数最终还会释放GPI...
Linux创建一个空洞文件
zhang45596961的专栏
02-23 2387
在使用迅雷下载的时候，查看迅雷新建的文件发现该文件大小和要下载的文件一样大 其实迅雷事先在本地创建了一个与要下载一样大的临时文件，然后后面通过多线程方式 从网络上下载这个文件，一点点填入那个临时文件 创建空洞文件代码如下： #include #include #include #include #define N_M 10*1024*1024 int main(int argc
Linux应用编程之空洞文件
shengnan89的博客
04-20 2119
空洞文件（hole file）的描述： 使用 lseek 可以修改文件的当前读写位置偏移量，此函数不但可以改变位置偏移量，并且还允许文件偏移量超出文件长度，这是什么意思呢？譬如有一个 test_file，该文件的大小是 4K（也就是 4096 个字节），可以通过 lseek 系统调用将该文件的读写偏移量移动到偏移文件头部 6000 个字节处。 接下来使用 write()函数对文件进行写入操作，也就是说此时将是从偏移文件头部 6000 个字节处开始写 入数据，也就意味着 4096~6000 字节之间.
linux命令打印日志,Linux命令nohup实现命令后台运行并输出到或记录到日志文件
weixin_34770855的博客
04-28 2008
后台运行命令：nohupnohup命令：nohup是不挂断的意思( no hang up)。如果你正在运行一个进程，而且你觉得在退出帐户时该进程还不会结束，那么可以使用nohup命令。该命令忽略所有挂(SIGHUP)信号，可以在你退出帐户/关闭终端之后继续运行相应的进程。该命令的一般格式为：nohupyourcommand&#yourcommand:启动对象命令。可以跟该命令需要的各...
linux是一个工程而不是理论
TCP/IP
02-09 3168
今天无聊的时候看了一会linux的FAQ，里面着重提出，linux不是一个很好的计算机科学理论而是一个很好的工程，很多人在邮件列表中提出一个新的想法，真的是很有创意的想法，但是很无情的被那些大牛们给咔嚓了，然后Linus或者Alan Cox等人就会给人一种很不随和的形象，其实他们都很忙，都有自己的工作，对于他们来说，写代码并且给出测试数据比空洞地谈理论要好得多，他们是典型的实践派，如果你提出了一个
多线程(七)线程池详解
淡淡的倔强的博客
03-30 2134
引言在 多线程(一) 多线程介绍及基本使用中我提及了线程池及常见的四种线程池，在这章推荐大神的博文，希望大家共同学习，讨论！本文原始地址：http://blog.youkuaiyun.com/ghsau/article/details/53538303。回顾四种常见线程池： 常见线程池： ①newSingleThreadExecutor   单个线程的线程池，即线程池中每次只有一个线程工作，单线程串行
Java并发（六）：线程本地变量ThreadLocal、再聊线程池
vanpersie_9987的博客
03-28 4992
本文来自：高爽|Coder，原文地址：http://blog.youkuaiyun.com/ghsau/article/details/7451464，转载请注明。ThreadLocal首先说明ThreadLocal存放的值是线程内共享的，线程间互斥的，主要用于线程内共享一些数据，避免通过参数来传递，这样处理后，能够优雅的解决一些实际问题。public class ConnectionManager {
创建线程的几种方式？8 年 Java 开发：从业务场景到代码实战（附避坑指南）
Minoz_wl的博客
08-28 1473
作为一名摸爬滚打 8 年的 Java 开发，从刚入行时 “new Thread () 一把梭”，到后来电商高并发场景下 “线程池参数调优到凌晨”，再到现在微服务异步链路用 “CompletableFuture 链式调用”，创建线程的方式选不对，不仅会踩坑（比如 OOM、线程泄露），还会直接影响系统性能。
脑机接口（BCI）常用开发语言全景分析：从信号处理到系统构建的技术选型指南
AllenLV的博客
11-23 1135
本文系统分析了脑机接口（BCI）开发中的主流编程语言生态。Python凭借丰富的科学计算库成为算法开发的首选；MATLAB以其专业工具箱在科研领域占据优势；C/C++凭借高性能特性在实时处理和硬件交互中发挥关键作用；Java则擅长跨平台应用开发与系统集成。这些语言各具优势，在不同技术环节协同配合，共同推动BCI技术的发展。文章为开发者提供了全面的技术选型参考，有助于根据具体应用场景选择最合适的编程语言组合。
AlmaLinux9配置本地镜像仓库
weixin_50877409的博客
12-04 181
本文介绍了在AlmaLinux 9.7系统中配置本地yum仓库的步骤：1）创建挂载目录并挂载ISO镜像；2）备份原有repo文件并创建local.repo配置文件；3）设置本地仓库路径为/media/cdrom/AppStream；4）清除并重建yum缓存；5）最后通过成功安装telnet包验证了本地仓库配置的正确性。整个过程实现了不依赖网络使用本地ISO镜像作为软件源的目的。
99-在Linux上安装Anaconda
12-03 208
【代码】99-在Linux上安装Anaconda。
Linux 进程状态与进程管理命令
qq_52537313的博客
12-04 808
在 Linux 系统中，是程序的运行实例，是操作系统资源分配和调度的基本单位。进程从创建到终止会经历多种状态，通过进程管理命令可以查看、监控和控制这些状态。本教程将结合核心命令，全方位讲解进程状态及管理方法。
Linux 中替换某个目录下所有文件中的特定字符串
liweiweili126的博客
12-02 685
在 Linux 中替换某个目录下所有文件中的特定字符串，核心是用 findsed组合，支持灵活扩展（如备份原文件、过滤文件类型、排除目录等）。
Linux设备管理：从内核驱动到用户空间的完整架构解析
X
12-03 800
A[物理硬件插入/移除] --> B[内核驱动探测]B --> C{Linux统一设备模型 LDM}C --> D[在/sysfs创建对象]C --> E[发送uevent事件]D --> F[用户空间工具<br>lspci, lsusb等]E --> G[UDEV守护进程]G --> H[扫描规则库 /etc/udev/rules.d/]H --> I[匹配并执行规则]I --> J1[创建设备节点 /dev/]I --> J2[设置权限与所有权]I --> J3[执行自定义脚本]
Linux物理内存管理-引导内存分配器
tang_vincent的博客
12-05 546
本文深入分析了Linux早期物理内存管理框架memblock的原理与实现。memblock作为引导内存分配器，在伙伴系统初始化前负责物理内存管理，通过memory数组记录总物理内存，reserved数组记录预留内存。文章详细解读了memblock的数据结构、初始化流程、关键接口(memblock_add/reserve/alloc/free等)实现，以及最终将内存释放到伙伴系统的过程。通过设备树解析获取物理内存范围，并对内核代码段、预留内存等特殊区域进行处理，memblock为内核启动阶段提供了可靠的内存管
Linux---＜unistd.h＞类Unix系统编程核心头文件
MzKyle的博客
12-04 666
<unistd.h>是Unix/Linux系统编程的核心头文件，提供底层系统调用接口。它封装了文件操作、进程管理等基础功能，是开发系统级程序的必备依赖。该头文件包含关键宏定义（如文件描述符STDIN_FILENO）、权限检查常量（R_OK/W_OK）以及文件操作函数（access/chmod/read/write等）。通过文件描述符机制，开发者可直接与内核交互，实现高效I/O操作。典型应用包括权限管理、文件重定向（dup2）和原始I/O读写。所有类Unix系统原生支持，但Windows需通过兼容
CobaltStrike横向渗透之Https Beacon实战2（跳板机Linux）
最新发布
mooyuan的网络安全博客
12-05 805
本文介绍了通过CobaltStrike实现Linux跳板机内网横向渗透的完整过程。攻击者首先创建两个HTTPS监听器（10088和22222端口），生成连接跳板机内网IP的HTTPSBeacon程序22222.exe。该程序通过跳板机上传至内网主机执行后，会主动连接跳板机的22222端口。跳板机通过配置iptables规则，将22222端口的HTTPS流量转发至攻击机的10088端口，最终建立攻击机→跳板机→内网主机的HTTPS C2通道。
【linux 系统NTP】ntpd | chrony 时钟同步
weixin_49929829的博客
12-01 538
Linux系统NTP时钟同步的ntpd与chrony同步方式
嵌入式Linux性能调优实战指南
"嵌入式Linux性能详解.pdf"是一本专注于Linux系统下，特别是手机平台的性能调优的书籍。作者史子旺通过其个人博客http://blog.chinaunix.net/u/30686/分享了丰富的专业知识，旨在帮助读者深入理解并提升Linux系统的...
评论 61
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值