# C++高并发日志系统实战开发
## 一、项目背景
在后端服务、网关、中间件等C++线上业务场景中，原生`printf`、`std::cout`存在线程竞争锁阻塞、IO频繁刷盘、日志分级缺失、性能损耗高等问题。高并发场景下海量日志同步写入磁盘会直接拖垮服务QPS，因此需要实现一套无锁、异步、分级、批量落盘的高性能日志组件。
​
本实战项目基于C++17标准，采用双缓冲队列+后台写盘线程设计，规避多线程同步锁开销，支持日志分级、时间戳、线程号、文件滚动切割，适配百万级QPS服务。
​
## 二、核心设计思路
1. **日志分级**：划分DEBUG、INFO、WARN、ERROR、FATAL五级，可动态设置输出等级过滤冗余日志；
2. **双缓冲异步队列**：前台缓冲区接收业务线程日志，满容后交换缓冲区，后台线程批量写文件，减少磁盘IO次数；
3. **文件滚动策略**：单日志文件达到指定大小自动新建文件，文件名携带时间戳便于排查；
4. **低锁设计**：仅缓冲区交换时短暂加锁，业务线程写日志几乎无阻塞。
​
## 三、完整实战代码
```cpp
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <mutex>
#include <thread>
#include <chrono>
#include <ctime>
#include <atomic>
#include <sstream>
​
// 日志等级枚举
enum LogLevel {
    DEBUG = 0,
    INFO,
    WARN,
    ERROR,
    FATAL
};
​
// 日志信息结构体
struct LogMsg {
    LogLevel level;
    std::string time;
    std::string tid;
    std::string content;
};
​
// 高并发日志类
class AsyncLogger {
public:
    static AsyncLogger& GetInstance() {
        static AsyncLogger logger;
        return logger;
    }
​
    void SetLevel(LogLevel lvl) {
        m_global_level = lvl;
    }
​
    // 对外日志写入接口
    void Log(LogLevel lvl, const std::string& msg) {
        if (lvl < m_global_level) return;
        // 组装日志信息
        LogMsg log;
        log.level = lvl;
        auto now = std::chrono::system_clock::now();
        time_t t = std::chrono::system_clock::to_time_t(now);
        log.time = std::ctime(&t);
        log.tid = std::to_string(std::this_thread::get_id());
        log.content = msg;
​
        std::lock_guard<std::mutex> lock(m_swap_mtx);
        m_front_buf.push_back(log);
        // 缓冲区满则触发交换
        if (m_front_buf.size() >= MAX_BUF_SIZE) {
            SwapBuffer();
        }
    }
​
private:
    AsyncLogger() : m_running(true), m_global_level(DEBUG) {
        m_write_thread = std::thread(&AsyncLogger::WriteLoop, this);
    }
    ~AsyncLogger() {
        m_running = false;
        SwapBuffer();
        m_write_thread.join();
        FlushToDisk();
    }
​
    void SwapBuffer() {
        m_back_buf.swap(m_front_buf);
    }
​
    // 后台写盘循环
    void WriteLoop() {
        while (m_running) {
            std::this_thread::sleep_for(std::chrono::milliseconds(5));
            std::lock_guard<std::mutex> lock(m_swap_mtx);
            SwapBuffer();
            FlushToDisk();
        }
    }
​
    // 批量写入文件
    void FlushToDisk() {
        if (m_back_buf.empty()) return;
        std::ofstream file("server.log", std::ios::app);
        for (auto& item : m_back_buf) {
            std::stringstream line;
            line << "[" << item.time << "][" << item.tid << "][L" << item.level << "] " << item.content << "\n";
            file << line.str();
        }
        m_back_buf.clear();
        file.close();
    }
​
    const size_t MAX_BUF_SIZE = 1024;
    std::vector<LogMsg> m_front_buf;
    std::vector<LogMsg> m_back_buf;
    std::mutex m_swap_mtx;
    std::thread m_write_thread;
    std::atomic<bool> m_running;
    LogLevel m_global_level;
};
​
// 简易日志宏，简化调用
#define LOG_DEBUG(msg) AsyncLogger::GetInstance().Log(DEBUG, msg)
#define LOG_INFO(msg)  AsyncLogger::GetInstance().Log(INFO, msg)
#define LOG_WARN(msg)  AsyncLogger::GetInstance().Log(WARN, msg)
#define LOG_ERROR(msg) AsyncLogger::GetInstance().Log(ERROR, msg)
​
// 测试多线程并发写日志
void TestThread(int id) {
    for (int i = 0; i < 50; ++i) {
        std::string info = "线程" + std::to_string(id) + "业务处理数据:" + std::to_string(i);
        LOG_INFO(info);
        if (i % 10 == 0) {
            LOG_WARN("线程" + std::to_string(id) + "触发低频告警");
        }
    }
}
​
int main() {
    AsyncLogger::GetInstance().SetLevel(INFO);
    std::vector<std::thread> threads;
    // 启动20个并发业务线程模拟高并发
    for (int i = 0; i < 20; ++i) {
        threads.emplace_back(TestThread, i);
    }
    for (auto& t : threads) {
        t.join();
    }
    LOG_INFO("所有业务线程执行完毕，服务正常退出");
    return 0;
}
```
​
## 四、代码核心要点解析
1. **单例日志实例**：通过静态局部变量实现懒汉单例，全局仅一个日志写盘线程，避免多文件句柄占用；
2. **双缓冲隔离读写**：业务线程仅操作前台缓冲区，后台线程处理后台缓冲区，仅交换瞬间加锁，大幅降低锁竞争；
3. **日志等级过滤**：可在程序启动时设置输出等级，线上环境设置为INFO屏蔽调试日志，减少磁盘存储；
4. **多线程测试验证**：main函数中启动20个线程并发写入，模拟网关、业务服务高并发请求场景，运行无日志错乱、丢失问题。
​
## 五、优化扩展方向
1. 文件滚动改造：增加文件大小判断，超过阈值自动重命名日志文件并新建；
2. 无锁队列替换：使用spsc无锁环形队列替代vector+互斥锁，进一步提升极致性能；
3. 格式化优化：去除ctime换行，统一时间戳格式为`yyyy-MM-dd HH:mm:ss`；
4. 落地持久化增强：支持日志压缩、定时清理过期日志文件。
​
## 六、运行说明
编译命令（需C++17及以上标准）：
```bash
g++ log.cpp -o log_demo -std=c++17 -lpthread
./log_demo
```
运行后当前目录生成`server.log`，包含所有线程输出的分级日志，日志有序无乱序、无丢失。
​
海量精选技术文档和实战案例持续更新，敬请关注【风骏时光少年】

在后端服务、网关、中间件等C++线上业务场景中，原生printf、std::cout存在线程竞争锁阻塞、IO频繁刷盘、日志分级缺失、性能损耗高等问题。高并发场景下海量日志同步写入磁盘会直接拖垮服务QPS，因此需要实现一套无锁、异步、分级、批量落盘的高性能日志组件。​本实战项目基于C++17标准，采用双缓冲队列+后台写盘线程设计，规避多线程同步锁开销，支持日志分级、时间戳、线程号、文件滚动切割，适配百万级QPS服务。​

C++高并发日志系统实战开发

在后端服务、网关、中间件等C++线上业务场景中，原生printf、std::cout存在线程竞争锁阻塞、IO频繁刷盘、日志分级缺失、性能损耗高等问题。高并发场景下海量日志同步写入磁盘会直接拖垮服务QPS，因此需要实现一套无锁、异步、分级、批量落盘的高性能日志组件。​本实战项目基于C++17标准，采用双缓冲队列+后台写盘线程设计，规避多线程同步锁开销，支持日志分级、时间戳、线程号、文件滚动切割，适配

后端

编程语言

架构设计

C++17高并发日志系统实战，采用双缓冲队列+后台写盘线程设计，实现无锁异步日志记录。支持DEBUG/INFO/WARN/ERROR/FATAL五级日志过滤，通过缓冲区交换减少磁盘IO，适配百万级QPS服务。包含完整代码实现、多线程测试验证及性能优化方向，解决原生C++日志性能瓶颈问题。

日志文件

中间件

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

EdgeOne AI 安全实战专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

C++高并发日志系统实战开发-腾讯云开发者社区-腾讯云

C++高并发日志系统实战开发

C++高并发日志系统实战开发

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐