高并发日志系统架构设计
面试考点
日志系统是每个后端服务的基础组件。面试官通过这道题考察你是否理解高并发场景下的日志系统设计:异步日志、无锁队列、多 Sink 输出、日志级别过滤、格式化性能优化,以及如何在吞吐量和可靠性之间做权衡。
核心概念
高并发日志系统的核心挑战是:多个业务线程同时产生日志,不能让日志 I/O 阻塞业务逻辑。解决方案是异步日志架构——业务线程只负责把日志消息放入队列(生产者),由专门的后台线程从队列中取出消息并写入文件/网络(消费者)。队列通常使用无锁环形缓冲区来减少线程竞争。
架构概览
业务线程1 ──┐
业务线程2 ──┼──→ [无锁环形队列] ──→ 后台写入线程 ──→ Sink1(文件)
业务线程3 ──┤ ──→ Sink2(控制台)
业务线程N ──┘ ──→ Sink3(网络)基本示例
#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 等工业级库的核心优化思路。