高并发日志系统架构设计 ​

面试考点 ​

日志系统是每个后端服务的基础组件。面试官通过这道题考察你是否理解高并发场景下的日志系统设计:异步日志、无锁队列、多 Sink 输出、日志级别过滤、格式化性能优化,以及如何在吞吐量和可靠性之间做权衡。

核心概念 ​

高并发日志系统的核心挑战是:多个业务线程同时产生日志,不能让日志 I/O 阻塞业务逻辑。解决方案是异步日志架构——业务线程只负责把日志消息放入队列(生产者),由专门的后台线程从队列中取出消息并写入文件/网络(消费者)。队列通常使用无锁环形缓冲区来减少线程竞争。

架构概览 ​

业务线程1 ──┐
业务线程2 ──┼──→ [无锁环形队列] ──→ 后台写入线程 ──→ Sink1(文件)
业务线程3 ──┤                                    ──→ Sink2(控制台)
业务线程N ──┘                                    ──→ Sink3(网络)

基本示例 ​

cpp
#include <iostream>
#include <fstream>
#include <string>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <vector>
#include <queue>
#include <atomic>
#include <chrono>
#include <functional>
#include <memory>
#include <sstream>
#include <iomanip>
#include <ctime>

// ============================
// 日志级别定义
// ============================

enum class LogLevel {
    Trace = 0,
    Debug = 1,
    Info = 2,
    Warn = 3,
    Error = 4,
    Fatal = 5,
    Off = 6
};

const char* level_to_string(LogLevel level) {
    switch (level) {
        case LogLevel::Trace: return "TRACE";
        case LogLevel::Debug: return "DEBUG";
        case LogLevel::Info:  return "INFO ";
        case LogLevel::Warn:  return "WARN ";
        case LogLevel::Error: return "ERROR";
        case LogLevel::Fatal: return "FATAL";
        default: return "?????";
    }
}

// ============================
// 日志消息结构
// ============================

struct LogMessage {
    LogLevel level;
    std::string content;
    std::thread::id thread_id;
    std::chrono::system_clock::time_point timestamp;
    const char* file;    // __FILE__
    int line;            // __LINE__

    LogMessage() = default;

    LogMessage(LogLevel lvl, std::string msg,
               const char* f = "", int l = 0)
        : level(lvl)
        , content(std::move(msg))
        , thread_id(std::this_thread::get_id())
        , timestamp(std::chrono::system_clock::now())
        , file(f)
        , line(l) {}
};

// ============================
// 格式化器
// ============================

class Formatter {
public:
    // 格式化日志消息为字符串
    std::string format(const LogMessage& msg) const {
        std::ostringstream oss;

        // 时间戳
        auto time_t = std::chrono::system_clock::to_time_t(msg.timestamp);
        auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
            msg.timestamp.time_since_epoch()) % 1000;

        std::tm tm_buf;
#ifdef _WIN32
        localtime_s(&tm_buf, &time_t);
#else
        localtime_r(&time_t, &tm_buf);
#endif

        oss << std::put_time(&tm_buf, "%Y-%m-%d %H:%M:%S")
            << '.' << std::setfill('0') << std::setw(3) << ms.count()
            << " [" << level_to_string(msg.level) << "]"
            << " [" << msg.thread_id << "]";

        if (msg.file[0] != '\0') {
            oss << " [" << msg.file << ":" << msg.line << "]";
        }

        oss << " " << msg.content << "\n";
        return oss.str();
    }
};

// ============================
// Sink 接口(输出目标)
// ============================

class Sink {
public:
    virtual ~Sink() = default;
    virtual void write(const std::string& formatted_msg) = 0;
    virtual void flush() = 0;
};

// 控制台 Sink
class ConsoleSink : public Sink {
public:
    void write(const std::string& msg) override {
        std::cout << msg;
    }
    void flush() override {
        std::cout.flush();
    }
};

// 文件 Sink
class FileSink : public Sink {
public:
    explicit FileSink(const std::string& filename)
        : file_(filename, std::ios::app) {}

    void write(const std::string& msg) override {
        if (file_.is_open()) {
            file_ << msg;
        }
    }

    void flush() override {
        if (file_.is_open()) {
            file_.flush();
        }
    }

private:
    std::ofstream file_;
};

// 滚动文件 Sink(按大小滚动)
class RotatingFileSink : public Sink {
public:
    RotatingFileSink(const std::string& base_name,
                     size_t max_size, int max_files)
        : base_name_(base_name)
        , max_size_(max_size)
        , max_files_(max_files)
        , current_size_(0) {
        file_.open(base_name_, std::ios::app);
        // 获取当前文件大小
        if (file_.is_open()) {
            file_.seekp(0, std::ios::end);
            current_size_ = static_cast<size_t>(file_.tellp());
        }
    }

    void write(const std::string& msg) override {
        if (!file_.is_open()) return;

        // 检查是否需要滚动
        if (current_size_ + msg.size() > max_size_) {
            rotate();
        }

        file_ << msg;
        current_size_ += msg.size();
    }

    void flush() override {
        if (file_.is_open()) file_.flush();
    }

private:
    void rotate() {
        file_.close();
        // 滚动文件:log.2 → log.3, log.1 → log.2, log → log.1
        for (int i = max_files_ - 1; i > 0; i--) {
            std::string src = base_name_ + "." + std::to_string(i);
            std::string dst = base_name_ + "." + std::to_string(i + 1);
            std::rename(src.c_str(), dst.c_str());
        }
        std::rename(base_name_.c_str(),
                    (base_name_ + ".1").c_str());
        file_.open(base_name_, std::ios::trunc);
        current_size_ = 0;
    }

    std::string base_name_;
    size_t max_size_;
    int max_files_;
    size_t current_size_;
    std::ofstream file_;
};

// ============================
// 异步日志引擎(核心)
// ============================

class AsyncLogger {
public:
    AsyncLogger(LogLevel min_level = LogLevel::Info,
                size_t queue_size = 8192)
        : min_level_(min_level)
        , running_(true)
        , flush_interval_(std::chrono::seconds(3)) {
        // 启动后台写入线程
        worker_ = std::thread(&AsyncLogger::worker_loop, this);
    }

    ~AsyncLogger() {
        // 关闭:先处理完队列中的消息
        running_ = false;
        cv_.notify_one();
        if (worker_.joinable()) {
            worker_.join();
        }
        // 刷新所有 sink
        for (auto& sink : sinks_) {
            sink->flush();
        }
    }

    // 添加输出目标
    void add_sink(std::shared_ptr<Sink> sink) {
        sinks_.push_back(std::move(sink));
    }

    // 设置最低日志级别
    void set_level(LogLevel level) {
        min_level_.store(level, std::memory_order_relaxed);
    }

    // 记录日志(业务线程调用,非阻塞)
    void log(LogLevel level, std::string message,
             const char* file = "", int line = 0) {
        // 级别过滤(编译期和运行期双重过滤)
        if (level < min_level_.load(std::memory_order_relaxed)) {
            return;
        }

        // 构造消息并放入队列
        LogMessage msg(level, std::move(message), file, line);

        {
            std::lock_guard<std::mutex> lock(mutex_);
            queue_.push(std::move(msg));
        }
        cv_.notify_one();
    }

    // 强制刷新
    void flush() {
        for (auto& sink : sinks_) {
            sink->flush();
        }
    }

private:
    // 后台写入线程的主循环
    void worker_loop() {
        while (true) {
            std::vector<LogMessage> batch;

            {
                std::unique_lock<std::mutex> lock(mutex_);
                // 等待新消息或超时(用于定期刷新)
                cv_.wait_for(lock, flush_interval_, [this]() {
                    return !queue_.empty() || !running_;
                });

                // 批量取出所有消息(减少锁竞争)
                while (!queue_.empty()) {
                    batch.push_back(std::move(queue_.front()));
                    queue_.pop();
                }
            }

            // 格式化并写入(在锁外执行,不阻塞生产者)
            for (const auto& msg : batch) {
                std::string formatted = formatter_.format(msg);
                for (auto& sink : sinks_) {
                    sink->write(formatted);
                }
            }

            // 批量刷新
            if (!batch.empty()) {
                for (auto& sink : sinks_) {
                    sink->flush();
                }
            }

            // 退出条件:停止标志 + 队列为空
            if (!running_ && batch.empty()) {
                break;
            }
        }
    }

    std::atomic<LogLevel> min_level_;
    std::atomic<bool> running_;
    std::chrono::seconds flush_interval_;

    std::mutex mutex_;
    std::condition_variable cv_;
    std::queue<LogMessage> queue_;

    std::thread worker_;
    Formatter formatter_;
    std::vector<std::shared_ptr<Sink>> sinks_;
};

// ============================
// 便捷宏
// ============================

// 全局 logger 实例
inline AsyncLogger& get_global_logger() {
    static AsyncLogger logger;
    return logger;
}

#define LOG_TRACE(msg) get_global_logger().log(LogLevel::Trace, msg, __FILE__, __LINE__)
#define LOG_DEBUG(msg) get_global_logger().log(LogLevel::Debug, msg, __FILE__, __LINE__)
#define LOG_INFO(msg)  get_global_logger().log(LogLevel::Info,  msg, __FILE__, __LINE__)
#define LOG_WARN(msg)  get_global_logger().log(LogLevel::Warn,  msg, __FILE__, __LINE__)
#define LOG_ERROR(msg) get_global_logger().log(LogLevel::Error, msg, __FILE__, __LINE__)
#define LOG_FATAL(msg) get_global_logger().log(LogLevel::Fatal, msg, __FILE__, __LINE__)

// ============================
// 使用演示
// ============================

int main() {
    // 配置 logger
    auto& logger = get_global_logger();
    logger.set_level(LogLevel::Debug);
    logger.add_sink(std::make_shared<ConsoleSink>());
    logger.add_sink(std::make_shared<FileSink>("app.log"));

    // 多线程写日志
    std::vector<std::thread> threads;
    for (int i = 0; i < 4; i++) {
        threads.emplace_back([i]() {
            for (int j = 0; j < 10; j++) {
                LOG_INFO("线程 " + std::to_string(i) +
                         " 消息 " + std::to_string(j));
            }
        });
    }

    LOG_WARN("主线程警告消息");
    LOG_ERROR("主线程错误消息");

    for (auto& t : threads) t.join();

    // logger 析构时会自动刷新剩余消息
    return 0;
}

架构设计要点 ​

组件职责关键设计
LogMessage日志消息载体时间戳、级别、线程ID、源文件位置
Formatter消息格式化可定制格式、thread_local 缓存减少分配
Sink输出目标多态接口、文件/控制台/网络
Queue生产者-消费者缓冲无锁环形缓冲区或带锁队列
Worker后台写入线程批量处理、定期刷新

同步 vs 异步日志 ​

特性同步日志异步日志
业务线程阻塞是(等待 I/O)否(只入队)
吞吐量低(受 I/O 限制)高(5-8 倍提升)
日志丢失风险无崩溃时可能丢失队列中的消息
内存使用低高(队列缓冲区)
实现复杂度低中
日志顺序严格有序多线程间可能乱序

队列满时的策略 ​

策略行为适用场景
阻塞等待生产者等待队列有空位日志不可丢失(审计、交易)
丢弃最新丢弃当前消息高吞吐场景,日志可丢
丢弃最旧覆盖队列头部只关心最新日志
动态扩容队列自动增长内存充足的场景

常见问题 ​

为什么不直接用 mutex 保护文件写入?

mutex 保护文件写入意味着每条日志都要获取锁、格式化、写磁盘、释放锁。在高并发下,所有业务线程都在等待这个锁,I/O 延迟直接影响业务逻辑。异步日志让业务线程只做入队操作(微秒级),I/O 交给后台线程,把 I/O 延迟从关键路径上移除。

崩溃时如何防止日志丢失?

几种方案:1) 对关键日志(Fatal、Error)使用同步刷新;2) 定期 flush(如每 3 秒);3) 使用信号处理器在崩溃时刷新队列;4) 使用 mmap 映射日志文件,OS 会负责持久化。权衡:刷新越频繁越安全,但吞吐量越低。

spdlog 是怎么做到高性能的?

几个关键优化:1) 无锁环形缓冲区(MPSC)减少线程竞争;2) thread_local 缓存减少动态内存分配;3) 编译期日志级别过滤(零开销移除低级别日志);4) 批量写入减少系统调用次数;5) fmt 库的高效格式化。

适用场景 ​

  • 高并发服务器的请求日志
  • 交易系统的审计日志
  • 分布式系统的链路追踪
  • 性能敏感的实时系统

注意事项 ​

  • 异步日志的队列大小需要根据峰值流量调整
  • Fatal 级别日志应同步刷新到磁盘
  • 滚动文件需要考虑磁盘空间管理
  • 格式化操作可以放在后台线程(减少生产者开销)或放在生产者线程(保留源文件信息)
  • 多个 logger 实例共享后台线程池可以减少线程开销

总结 ​

高并发日志系统的核心是异步架构:业务线程只负责入队(微秒级),后台线程负责格式化和 I/O。关键组件包括无锁/低锁队列、可扩展的 Sink 接口、可定制的 Formatter、以及合理的刷新策略。面试中要能画出架构图,解释同步 vs 异步的权衡、队列满时的策略选择、崩溃时的数据安全保障,以及 spdlog 等工业级库的核心优化思路。