多线程进程中自定义Logger日志写入截断问题咨询

嘿，你这个问题太典型了——我之前帮好几个开发者搞定过类似的流式Logger多线程截断坑！你已经把多目标输出（屏幕、文件这些）弄明白了，就差最后一步线程安全的保障，下面给你几个实用的解决思路，从简单到进阶都有：

1. 给每条日志加线程专属缓冲区（最直接的同步方案） #

核心逻辑是：让同一条日志的所有内容先在当前线程的独立缓冲区里攒齐，再一次性输出到所有目标，彻底避免中途被其他线程打断。

• 用C++的thread_local给每个线程分配专属的临时缓冲区，这样线程之间不会互相干扰：

  class Logger {
  private:
      // 线程局部存储的缓冲区，每个线程一份
      thread_local static std::ostringstream tls_buffer;
      // 全局互斥锁，保护最终的输出操作
      std::mutex m_output_mutex;
  public:
      // 重载<<，先把内容写入线程局部缓冲区
      template<typename T>
      Logger& operator<<(const T& value) {
          tls_buffer << value;
          return *this;
      }
  
      // 一次性输出缓冲区内容并清空
      void flush() {
          std::lock_guard<std::mutex> lock(m_output_mutex);
          const std::string log_content = tls_buffer.str();
          // 输出到屏幕
          std::cout << log_content;
          // 输出到日志文件
          // log_file << log_content;
          // ...其他输出目标
          tls_buffer.str(""); // 清空缓冲区，准备下一条日志
      }
  };
  
  // 初始化线程局部缓冲区
  thread_local std::ostringstream Logger::tls_buffer;
  

• 然后改造你的LOG宏，用临时对象的析构函数自动触发flush——这样用户写完一条日志语句，缓冲区就会自动输出：

  // 用LoggerGuard的析构自动完成flush
  class LoggerGuard {
  private:
      Logger& m_logger;
  public:
      explicit LoggerGuard(Logger& logger) : m_logger(logger) {}
      ~LoggerGuard() { m_logger.flush(); }
  
      // 转发<<操作到Logger
      template<typename T>
      LoggerGuard& operator<<(const T& value) {
          m_logger << value;
          return *this;
      }
  };
  
  // 最终的LOG宏，自动带文件、行号信息
  #define LOG() LoggerGuard(Logger()) << "[" << __FILE__ << ":" << __LINE__ << "] "
  

  现在用户写LOG() << "User " << user_id << " logged in successfully";，语句结束时LoggerGuard析构，整条日志会一次性输出，完全不会被截断。

2. 全局互斥锁直接保护输出（简单但性能一般） #

如果不想搞线程局部缓冲区，也可以直接给所有输出操作加锁，但要注意：不能给每个<<操作单独加锁，不然还是会被打断。必须保证整条日志的输出是原子操作。

• 错误示例（会被截断）：

  // 不要这么做！每个<<都会加锁解锁，线程切换会打断日志
  template<typename T>
  Logger& operator<<(const T& value) {
      std::lock_guard<std::mutex> lock(m_mutex);
      std::cout << value;
      return *this;
  }
  

• 正确做法还是结合缓冲区，或者把整条日志的输出逻辑包在锁里，但前者更灵活。这种方式适合对性能要求不高的小项目。

3. 异步日志队列（高性能进阶方案） #

如果你的项目线程多、日志量大，推荐用异步日志：把每条日志封装成独立条目，放到线程安全的队列里，再用一个单独的工作线程负责输出。主线程不用等输出完成，性能会好很多。

// 定义日志条目结构体，包含内容、时间、级别等信息
struct LogEntry {
    std::string content;
    std::chrono::system_clock::time_point timestamp;
    enum class Level { INFO, WARN, ERROR } level;
};

class AsyncLogger {
private:
    std::queue<LogEntry> m_log_queue;
    std::mutex m_queue_mutex;
    std::condition_variable m_cv;
    std::thread m_worker_thread;
    bool m_running = true;

    // 工作线程：从队列取日志并输出
    void worker_loop() {
        while (m_running) {
            std::unique_lock<std::mutex> lock(m_queue_mutex);
            // 等待队列有日志或者要停止
            m_cv.wait(lock, [this]() { return !m_log_queue.empty() || !m_running; });
            
            while (!m_log_queue.empty()) {
                auto entry = m_log_queue.front();
                m_log_queue.pop();
                lock.unlock();

                // 输出到所有目标，这里可以加格式处理
                std::cout << format_log(entry) << std::endl;
                // log_file << format_log(entry) << std::endl;

                lock.lock();
            }
        }
    }

    // 格式化日志内容的辅助函数
    std::string format_log(const LogEntry& entry) {
        // 这里可以加时间、级别等格式
        char time_buf[64];
        std::time_t t = std::chrono::system_clock::to_time_t(entry.timestamp);
        std::strftime(time_buf, sizeof(time_buf), "%Y-%m-%d %H:%M:%S", std::localtime(&t));
        return std::string(time_buf) + " [" + level_str(entry.level) + "] " + entry.content;
    }

    std::string level_str(LogEntry::Level level) {
        switch(level) {
            case LogEntry::Level::INFO: return "INFO";
            case LogEntry::Level::WARN: return "WARN";
            case LogEntry::Level::ERROR: return "ERROR";
            default: return "UNKNOWN";
        }
    }

public:
    AsyncLogger() {
        m_worker_thread = std::thread(&AsyncLogger::worker_loop, this);
    }

    ~AsyncLogger() {
        m_running = false;
        m_cv.notify_one();
        m_worker_thread.join();
    }

    // 重载<<，先写入线程局部缓冲区
    template<typename T>
    AsyncLogger& operator<<(const T& value) {
        thread_local std::ostringstream tls_buffer;
        tls_buffer << value;
        return *this;
    }

    // 结束日志，把缓冲区内容封装成LogEntry放入队列
    void flush(LogEntry::Level level = LogEntry::Level::INFO) {
        std::lock_guard<std::mutex> lock(m_queue_mutex);
        m_log_queue.push({
            tls_buffer.str(),
            std::chrono::system_clock::now(),
            level
        });
        tls_buffer.str("");
        m_cv.notify_one();
    }
};

// 对应的宏
#define LOG_INFO() AsyncLoggerGuard(AsyncLogger(), LogEntry::Level::INFO)
#define LOG_ERROR() AsyncLoggerGuard(AsyncLogger(), LogEntry::Level::ERROR)

class AsyncLoggerGuard {
private:
    AsyncLogger& m_logger;
    LogEntry::Level m_level;
public:
    AsyncLoggerGuard(AsyncLogger& logger, LogEntry::Level level) 
        : m_logger(logger), m_level(level) {}
    ~AsyncLoggerGuard() { m_logger.flush(m_level); }

    template<typename T>
    AsyncLoggerGuard& operator<<(const T& value) {
        m_logger << value;
        return *this;
    }
};

这种方式下，每条日志都是完整的条目进入队列，工作线程逐个输出，完全不会出现截断，而且主线程的日志操作几乎不耗时，适合高并发场景。

总结一下：小项目用线程局部缓冲区+自动flush就足够；高并发项目直接上异步日志队列，性能和可靠性都拉满。

内容的提问来源于stack exchange，提问作者binyamina