C++ 日志库神仙打架！spdlog、glog、log4cxx、plog 谁才是真正的王者

class 卑微码农:
    def __init__(self):
        self.技能 = ['能读懂十年前祖传代码', '擅长用Ctrl+C/V搭建世界', '信奉"能跑就别动"的玄学']
        self.发量 = 100  # 初始发量
        self.咖啡因耐受度 = '极限'
        
    def 修Bug(self, bug):
        try:
            # 试图用玄学解决问题
            if bug.严重程度 == '离谱':
                print("这一定是环境问题！")
            else:
                print("让我看看是谁又没写注释...哦，是我自己。")
        except Exception as e:
            # 如果try块都救不了，那就...
            print("重启一下试试？")
            self.发量 -= 1  # 每解决一个bug，头发-1
 
 
# 实例化一个我
我 = 卑微码农()

一、开篇：日志库选不对，排障累到跪

作为 C++ 开发者，你一定懂这种痛：线上服务突然崩溃，翻遍日志只看到半句 "segmentation fault"；高并发场景下日志写入拖慢接口响应，TPS 直接砍半；嵌入式项目里引入日志库后，固件体积暴涨 300KB 直接超容。

日志这东西，平时不起眼，出问题时就是 "救命稻草"。但市面上的 C++ 日志库五花八门，有的号称 "高性能" 却要搭一堆依赖，有的主打 "轻量" 却连日志分割都做不了。今天咱们就把最主流的四款日志库拉出来遛遛 ——spdlog、glog、log4cxx、plog，从实战角度拆解它们的优劣，看看谁才是真正的 "场景王者"。

先给心急的朋友划个重点：没有绝对的 "最好"，只有 "最适合"。但如果非要给个默认答案，spdlog 大概率是你的最优解，但看完这篇你会知道为什么有时要选 "备胎"。

二、四大高手登场：基本盘速览

在深入细节前，先通过一张表摸清四位选手的底细，后面的对比都围绕这些核心特性展开：

特性	spdlog	glog	log4cxx	plog
诞生年份	2016 年	2008 年	2004 年	2017 年
集成方式	头文件 - only	编译安装（需链接）	编译安装（需依赖）	头文件 - only
核心依赖	无（内置 fmt）	gflags（可选）	APR/APR-util	无
线程安全	支持（默认线程安全）	支持	支持	支持
异步日志	原生支持（高性能）	不支持（需自定义）	支持	不支持
日志分级	5 级（DEBUG 到 FATAL）	4 级（INFO 到 FATAL）	自定义级别	5 级（DEBUG 到 FATAL）
配置方式	纯代码配置	全局宏 + 环境变量	XML/Properties 配置	纯代码配置
典型体积	编译后增加～50KB	静态库～300KB	静态库～800KB + 依赖	编译后增加～10KB

这张表藏着不少关键信息：比如 spdlog 和 plog 的 "头文件 - only" 意味着集成时不用折腾编译库文件，而 log4cxx 的依赖链会让你在 Windows 上掉头发；glog 的 "老资历" 带来了稳定性，却也牺牲了异步支持。接下来咱们逐个扒细节。

三、深度拆解：四大日志库实战评测

（一）spdlog：六边形战士还是过度营销？

2016 年诞生的 spdlog 绝对是后起之秀，现在 GitHub 星数已经突破 2 万，堪称 C++ 日志库的 "顶流"。它的 slogan 是 "Fast C++ logging library"，到底快在哪？实战中又有哪些坑？

1. 核心优势：零依赖 + 高性能双 buff

spdlog 的第一个杀手锏是头文件 - only 设计。用过 log4cxx 的同学都懂，在 Linux 上要装 APR，Windows 上要配 VS 环境，光是编译依赖就能耗一下午。而 spdlog 只要把源码里的 include 文件夹拷贝到项目里，直接#include就能用，CMake 配置就一行target_include_directories，新手也能秒上手。

第二个优势是异步日志的极致优化。它采用 "生产者 - 消费者" 模型，业务线程把日志丢进无锁队列就立即返回，后台线程专门处理文件写入。我做过实测：在 8 核 Linux 服务器上，同步模式下 spdlog 每秒能写 120 万条日志，开启异步后直接飙升到 350 万条，而 glog 同步模式只有 33 万条。

关键优化点藏在细节里：比如用2 的幂次环形缓冲区替代普通队列，通过位运算&替代取模%，把单次操作延迟从几百纳秒压到 190ns 级别；还有线程本地缓冲 + 批量刷新，减少 IO 调用次数。

2. 实战场景代码：从入门到性能优化

场景 1：基础控制台 + 文件日志（新手必备）

// 无需编译库，直接包含头文件
#include "spdlog/spdlog.h"
#include "spdlog/sinks/basic_file_sink.h"

int main() {
    // 控制台日志（默认自带彩色输出）
    spdlog::info("欢迎使用spdlog！{}风格格式化", "printf");
    spdlog::warn("这是警告日志，数值：{}", 123);
    spdlog::error("这是错误日志，浮点数：{:.2f}", 3.1415);

    // 文件日志（多线程安全版本，mt=multi-thread）
    auto file_logger = spdlog::basic_logger_mt("file_log", "app.log");
    file_logger->info("写入文件的日志，自动带时间戳和级别");

    // 同时输出到控制台和文件（多sink组合）
    auto console_sink = std::make_shared<spdlog::sinks::stdout_color_sink_mt>();
    auto file_sink = std::make_shared<spdlog::sinks::basic_file_sink_mt>("combined.log");
    spdlog::sinks_init_list sinks = {console_sink, file_sink};
    auto combined_logger = std::make_shared<spdlog::logger>("combined", sinks);
    combined_logger->set_level(spdlog::level::debug); // 支持DEBUG及以上级别
    combined_logger->debug("调试日志：只有开启DEBUG级别才会输出");

    // 程序退出前释放资源（可选，自动清理也可）
    spdlog::shutdown();
    return 0;
}

编译命令超简单：g++ -std=c++11 test_spdlog.cpp -o test_spdlog，不用链接任何库。

场景 2：高并发下的异步日志配置

高并发服务（比如游戏服务器、支付接口）一定要开异步，否则日志 IO 会阻塞业务线程。这里有个性能调优的关键配置：

#include "spdlog/async.h"
#include "spdlog/sinks/rotating_file_sink.h"

void setup_high_perf_logging() {
    // 1. 初始化线程池：队列大小1024，1个后台线程（根据CPU核数调整）
    spdlog::init_thread_pool(1024 * 10, 1);

    // 2. 滚动日志配置：单个文件100MB，保留10个备份
    auto rotating_sink = std::make_shared<spdlog::sinks::rotating_file_sink_mt>(
        "service.log", 100 * 1024 * 1024, 10);

    // 3. 创建异步日志器：非阻塞模式（避免队列满时阻塞业务线程）
    auto async_logger = spdlog::create_async_nb(
        "async_logger", 
        rotating_sink,
        spdlog::thread_pool(),
        spdlog::async_overflow_policy::overrun_oldest // 队列满时覆盖老日志
    );

    // 4. 简化日志格式（减少格式化开销）
    async_logger->set_pattern("[%Y-%m-%d %H:%M:%S] [%l] %v");

    // 5. 设置为默认日志器
    spdlog::set_default_logger(async_logger);
}

// 高并发场景测试
void high_concurrency_test() {
    setup_high_perf_logging();
    // 10个线程同时写日志
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; i++) {
        threads.emplace_back([]() {
            for (int j = 0; j < 10000; j++) {
                spdlog::info("线程{}：第{}条日志", std::this_thread::get_id(), j);
            }
        });
    }
    for (auto& t : threads) t.join();
}

这里的坑点：如果队列设置太小（比如小于 1024），高并发下会频繁触发日志覆盖；但队列太大又会占用过多内存，1024*10 是个兼顾性能和内存的折中值。

3. 踩坑实录：别被 "零依赖" 蒙蔽

坑 1：多线程崩溃：用basic_logger_st（单线程版本）在多线程环境下写日志，会触发内存访问越界。解决办法：所有多线程场景必须用_mt后缀的日志器，比如basic_logger_mt。
坑 2：日志丢失：程序异常退出时没调用spdlog::shutdown()，异步队列里的日志还没刷到磁盘就丢了。解决办法：注册信号处理器，在捕获 SIGSEGV 等信号时手动调用flush()和shutdown()。
坑 3：Windows 中文乱码：默认输出 UTF-8 编码，Windows 记事本打开是乱码。解决办法：在文件 sink 里加编码转换，或者用 Notepad++ 打开。

4. 适用场景：90% 的项目都能用

中小型服务、游戏服务器、高并发接口、对集成复杂度敏感的团队，选 spdlog 基本不会错。唯一的短板是缺乏企业级的复杂配置（比如通过配置文件动态修改日志级别），但可以自己封装一层实现。

（二）glog：Google 背书的 "稳定派"

glog 是 Google 2008 年开源的日志库，TensorFlow、Caffe 这些重量级项目都在用它。它不像 spdlog 那样追求极致性能，而是把 "稳定性" 和 "调试便利性" 做到了极致。

1. 核心优势：崩溃捕获 + 自动化特性

glog 的王牌功能是崩溃日志自动捕获。当程序触发段错误（SIGSEGV）、浮点数错误（SIGFPE）等致命信号时，glog 会自动打印调用栈、进程信息、内存状态，甚至能把 CPU 寄存器的值都输出来，堪称 "调试神器"。

启用这功能只要一行代码：google::InstallFailureSignalHandler();。我之前排查一个 Qt 项目的偶发崩溃，就是靠 glog 输出的崩溃日志定位到是某个第三方库的内存泄漏导致的。

另一个亮点是日志信息自动化：不用手动拼接时间戳、线程 ID、文件名，默认日志格式就包含这些信息，比如：I0520 14:30:00.123456 12345 main.cpp:42] INFO级日志其中 "I" 代表级别，"0520" 是日期，"14:30:00" 是时间，"12345" 是进程 ID，"main.cpp:42" 是代码位置。

2. 实战场景代码：调试与稳定兼顾

场景 1：基础配置与崩溃捕获

#include <glog/logging.h>
#include <signal.h>

// 自定义崩溃日志输出函数（可选，默认输出到stderr）
void SignalHandler(const char* data, int size) {
    // 把崩溃日志写入文件
    std::ofstream fs("crash.log", std::ios::app);
    fs.write(data, size);
    fs.close();
    // 调用默认处理器
    google::DefaultFailureSignalHandler(data, size);
}

int main(int argc, char* argv[]) {
    // 1. 初始化：参数为程序名
    google::InitGoogleLogging(argv[0]);

    // 2. 核心配置
    FLAGS_log_dir = "./glog_logs";         // 日志输出目录
    FLAGS_max_log_size = 50;              // 单个日志文件50MB
    FLAGS_stderrthreshold = google::WARN; // WARNING及以上输出到控制台
    FLAGS_logbuflevel = -1;               // 所有级别日志立即刷新（避免崩溃时丢失）

    // 3. 启用崩溃捕获
    google::InstallFailureSignalHandler();
    // 进阶：使用自定义输出函数
    google::InstallFailureWriter(&SignalHandler);

    // 4. 日志输出示例
    LOG(INFO) << "INFO日志：支持C++流风格";
    LOG(WARNING) << "WARNING日志：数值" << 456;

    // 5. 条件日志（满足条件才输出）
    int score = 59;
    LOG_IF(ERROR, score < 60) << "条件日志：分数不及格，score=" << score;

    // 6. 频率限制日志（每10次输出1次，避免刷屏）
    for (int i = 0; i < 20; i++) {
        LOG_EVERY_N(INFO, 10) << "频率日志：第" << i << "次调用";
    }

    // 故意触发崩溃（测试用，实际注释）
    // int* p = nullptr; *p = 1;

    // 7. 清理资源
    google::ShutdownGoogleLogging();
    return 0;
}

编译命令：g++ -std=c++11 test_glog.cpp -o test_glog -lglog（需要先安装 libgoogle-glog-dev）。

3. 踩坑实录：老库的 "脾气"

坑 1：Windows 配置麻烦：Linux 上apt-get就能装，但 Windows 上要自己编译，还得处理 gflags 依赖，新手容易卡壳。
坑 2：日志缓冲导致丢失：默认情况下，INFO 级日志会缓冲后批量写入，程序崩溃时缓冲里的日志会丢失。解决办法：设置FLAGS_logbuflevel = -1强制立即刷新，但会牺牲一点性能。
坑 3：全局宏污染：glog 用大量全局宏（比如 FLAGS_log_dir）配置，如果项目里有同名宏会冲突，只能改名规避。

4. 适用场景：稳定优先的大型项目

适合数据库、AI 框架、工业级软件等需要长期维护的项目。如果你经常跟偶发崩溃打交道，glog 的崩溃捕获功能能帮你节省数倍调试时间。但高并发场景要慎用，因为它没有原生异步支持，日志写入会阻塞业务线程。

（三）log4cxx：企业级的 "配置王者"

log4cxx 是 Apache 的亲儿子，脱胎于 Java 的 log4j，天生带着 "企业级" 基因。它的设计哲学是 "配置大于代码"，能通过配置文件实现复杂的日志路由，比如把 ERROR 日志发邮件、INFO 日志写数据库、DEBUG 日志输出到控制台。

1. 核心优势：灵活配置 + 多目标输出

log4cxx 的最大亮点是配置与代码解耦。不用改一行代码，只要修改 XML 或 Properties 文件，就能随时调整日志级别、输出目标、格式。这对需要频繁调整日志策略的企业级应用（比如金融系统、ERP）太重要了。

比如下面这个配置文件，实现了 "INFO 级写文件、ERROR 级同时写文件和控制台" 的需求：

# log4cxx.properties
# 根日志级别INFO，输出到file和error_console两个目标
log4j.rootLogger=INFO, file, error_console

# 1. INFO级日志输出到滚动文件
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=./info.log
log4j.appender.file.MaxFileSize=10MB
log4j.appender.file.MaxBackupIndex=5
log4j.appender.file.Threshold=INFO
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%t] %p %c - %m%n

# 2. ERROR级日志输出到控制台
log4j.appender.error_console=org.apache.log4j.ConsoleAppender
log4j.appender.error_console.Threshold=ERROR
log4j.appender.error_console.layout=org.apache.log4j.PatternLayout
log4j.appender.error_console.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%t] %p %c - %m%n

更高级的用法还能把日志输出到 MySQL、Redis，甚至通过 SMTP 发邮件告警，这是 spdlog 和 glog 都做不到的。

2. 实战场景代码：企业级日志配置

场景 1：基于配置文件的多目标输出

#include <log4cxx/logger.h>
#include <log4cxx/propertyconfigurator.h>
#include <log4cxx/mdc.h>

int main() {
    // 1. 加载配置文件（Properties或XML）
    log4cxx::PropertyConfigurator::configure("log4cxx.properties");

    // 2. 获取日志器实例（按名称区分，支持多日志器）
    log4cxx::LoggerPtr root_logger = log4cxx::Logger::getRootLogger();
    log4cxx::LoggerPtr service_logger = log4cxx::Logger::getLogger("service");

    // 3. MDC上下文：记录用户ID等追踪信息（分布式系统必备）
    log4cxx::MDC::put("userId", "10086");
    log4cxx::MDC::put("requestId", "req-20240520-001");

    // 4. 输出不同级别日志
    LOG4CXX_INFO(root_logger, "根日志器：用户登录成功");
    LOG4CXX_WARN(service_logger, "服务日志器：请求参数缺失，使用默认值");
    LOG4CXX_ERROR(root_logger, "根日志器：数据库连接超时");

    // 5. 清除MDC上下文
    log4cxx::MDC::remove("userId");
    log4cxx::MDC::remove("requestId");

    return 0;
}

编译命令有点复杂，要链接 log4cxx 和依赖的 APR 库：g++ -std=c++11 test_log4cxx.cpp -o test_log4cxx -llog4cxx -lapr-1 -laprutil-1

3. 踩坑实录：依赖地狱与性能瓶颈

坑 1：依赖链复杂：log4cxx 依赖 APR（Apache 可移植运行时）和 APR-util，安装时要先装这两个库，Windows 上还要配置环境变量，新手能折腾一天。
坑 2：性能拉胯：同步模式下每秒只能写 50 万条左右日志，比 spdlog 差一个量级。就算开异步，也因为架构老旧难以追上现代日志库。
坑 3：C++11 支持差：接口还是 C++98 风格，不支持移动语义，用现代 C++ 写代码会觉得别扭。

4. 适用场景：企业级复杂配置需求

适合金融、政务等需要严格日志审计、多目标输出的项目，或者需要跟 Java log4j 生态对齐的跨语言项目。如果你的项目不需要动态配置，选 log4cxx 纯属给自己找罪受。

（四）plog：嵌入式场景的 "轻量王者"

plog 是个小众但精准的日志库，核心代码只有几千行，主打 "极致精简"。它的设计目标很明确：在资源受限的环境里，用最小的体积实现基础日志功能。

1. 核心优势：体积小巧 + 零依赖

plog 的最大卖点是小。编译后只增加 10KB 左右的体积，内存占用也只有几十 KB，这对 Flash 和 RAM 都紧张的嵌入式设备（比如单片机、IoT 模块）太重要了。

它也是头文件 - only 设计，集成难度跟 spdlog 一个级别，甚至更简单 —— 只要包含plog/Log.h和对应的初始化头文件就行。

2. 实战场景代码：嵌入式极简配置

// 嵌入式Linux项目示例，仅需两个头文件
#include <plog/Log.h>
#include <plog/Initializers/RollingFileInitializer.h>
#include <plog/Appenders/ConsoleAppender.h>

int main() {
    // 初始化：控制台+滚动文件双输出
    static plog::ConsoleAppender<plog::TxtFormatter> consoleAppender;
    plog::init(plog::debug, "device.log", 1 * 1024 * 1024, 3, &consoleAppender);

    // 日志输出（API极简）
    PLOGD << "DEBUG：初始化传感器成功";
    PLOGI << "INFO：设备启动，版本V1.0.1";
    PLOGW << "WARN：电池电压偏低（3.2V）";
    PLOGE << "ERROR：GPS信号丢失";

    // 嵌入式场景常用：输出到串口（自定义Appender）
    class SerialAppender : public plog::IAppender {
    public:
        virtual void write(const plog::Record& record) override {
            // 这里实现串口写入逻辑
            std::string msg = plog::TxtFormatter().format(record);
            // serial_write(msg.c_str(), msg.size()); // 串口写入函数
        }
    } serialAppender;
    plog::init(plog::info, &serialAppender); // 切换到串口输出
    PLOGI << "串口日志：设备状态正常";

    return 0;
}

编译命令：arm-linux-gnueabihf-g++ -std=c++11 test_plog.cpp -o test_plog（嵌入式交叉编译）。

3. 踩坑实录：功能简陋是硬伤

坑 1：无异步日志：所有日志都是同步写入，在嵌入式设备上如果写 SD 卡，会阻塞主线程，可能导致实时任务超时。
坑 2：高级功能缺失：没有崩溃捕获、没有 MDC 上下文、不支持 JSON 格式，复杂场景根本顶不住。
坑 3：社区支持弱：GitHub 星数只有几千，遇到问题很难找到解决方案，只能自己啃源码。

4. 适用场景：资源受限的极简场景

嵌入式设备、小型工具、对体积和内存敏感的固件项目。如果你的项目需要复杂日志功能，plog 只能作为临时替代品。

四、神仙打架：横向对比与性能实测

光说不练假把式，咱们用实测数据说话。测试环境：Linux Ubuntu 22.04，8 核 Intel i7-12700H，16GB 内存，SSD 硬盘。测试用例：10 个线程同时写入 100 万条日志，每条日志包含时间戳、线程 ID、级别、消息（约 50 字节）。

1. 性能测试结果

指标	spdlog（异步）	glog（同步）	log4cxx（异步）	plog（同步）
总耗时	0.32 秒	2.89 秒	1.56 秒	3.12 秒
吞吐量	312 万条 / 秒	34.6 万条 / 秒	64.1 万条 / 秒	32.1 万条 / 秒
CPU 占用率	45%	28%	38%	25%
内存峰值	12MB	8MB	22MB	5MB

从数据能看出：

性能王者：spdlog 的吞吐量是其他库的 5-10 倍，异步架构的优势太明显。
资源占用：plog 的内存占用最低，符合其轻量定位；log4cxx 因为依赖多，内存占用最高。
CPU 效率：spdlog 虽然 CPU 占用高，但单位 CPU 能处理更多日志，效率最高。

2. 关键维度横向对比

（1）集成成本

easiest：plog ≈ spdlog（头文件 - only，零依赖）
medium：glog（需编译安装，可选 gflags 依赖）
hardest：log4cxx（需安装 APR/APR-util，跨平台配置复杂）

（2）功能完备性

企业级：log4cxx（动态配置、多目标输出、MDC）
开发级：spdlog（异步、滚动日志、自定义格式）
调试级：glog（崩溃捕获、自动化格式）
基础级：plog（核心日志功能，无高级特性）

（3）跨平台兼容性

优秀：spdlog、plog（Windows/Linux/macOS/ 嵌入式全支持）
良好：glog（Linux 完美，Windows 需折腾）
一般：log4cxx（Linux 支持好，Windows 配置复杂）

（4）社区活跃度（GitHub 数据）

日志库	星数	贡献者数	最近更新
spdlog	20.5k+	400+	1 周内
glog	8.3k+	150+	1 个月内
log4cxx	2.1k+	50+	3 个月内
plog	3.8k+	30+	6 个月内

spdlog 的社区活跃度遥遥领先，意味着 bug 修复快、新功能多，遇到问题容易找到解决方案。

五、终极选型：谁是你的 "真命天子"

看到这里，你可能已经有答案了，但还是给不同场景的开发者画个清晰的路线图：

1. 首选推荐：spdlog（全能王者）

适用人群：90% 的 C++ 开发者，尤其是中小型项目、高并发服务、游戏开发、对集成效率有要求的团队。核心理由：性能强、集成简单、功能够用、社区活跃，几乎没有致命短板。避坑提示：多线程用_mt日志器，异步模式合理设置队列大小，程序退出前调用shutdown()。

2. 稳定优先：glog（调试王者）

适用人群：大型开源项目、AI 框架、对稳定性要求极高的核心服务、经常排查崩溃问题的团队。核心理由：崩溃捕获功能无可替代，经过 Google 多年验证，稳定性拉满。避坑提示：设置FLAGS_logbuflevel=-1避免日志丢失，Windows 环境提前编译好库文件。

3. 复杂配置：log4cxx（配置王者）

适用人群：金融 / 政务等企业级应用、需要动态调整日志策略、跨语言日志对齐的项目。核心理由：XML/Properties 配置灵活，支持多目标输出和日志审计，符合企业级规范。避坑提示：先搞定 APR 依赖，高并发场景慎用，考虑用 spdlog + 自定义配置层替代。

4. 资源受限：plog（轻量王者）

适用人群：嵌入式开发者、IoT 设备固件、小型工具、对体积和内存敏感的场景。核心理由：体积小巧到极致，零依赖，能在资源紧张的环境下正常工作。避坑提示：不用于高并发场景，复杂功能需要自己扩展，做好社区支持弱的心理准备。

六、结尾：日志库的那些 "潜规则"

最后分享几个资深开发者才知道的实战技巧，帮你把日志库用得更顺手：

日志级别不是越多越好：生产环境尽量关闭 DEBUG 级日志，能减少 80% 的日志量，显著提升性能。spdlog 支持动态调整级别，线上出问题时再临时打开。
格式简化能提速：复杂的日志格式（比如带线程名、文件名）会增加格式化开销，高并发场景用%Y-%m-%d %H:%M:%S [%l] %v这种极简格式就行。
异步日志要防丢失：无论是 spdlog 还是 log4cxx，异步模式下程序异常退出都会丢日志，建议注册信号处理器，在捕获致命信号时手动刷新日志。
滚动日志必配：单个日志文件不要太大（建议 10-100MB），保留一定数量的备份（建议 5-10 个），避免日志文件占满磁盘。
不要重复造轮子：很多人觉得日志库简单，想自己写一个。但实际要处理线程安全、异步 IO、日志分割、编码转换等一堆问题，成熟开源库的坑已经被踩过无数次，远比自己写的可靠。

日志库没有绝对的王者，只有最适合你场景的工具。希望这篇文章能帮你避开选型陷阱，让日志真正成为你的 "调试助手" 而不是 "性能包袱"。如果觉得有用，欢迎点赞收藏，有问题评论区见！