A while ago, on a whim, I decided to write my own management program for a cross-platform console service-class application I was using, in order to add some features. Thus, I designed a simple service operation flow.

WARNING
The views and solutions in this series of articles are designed by me based on my existing knowledge combined with assistance from DeepSeek. They have not been rigorously tested and do not guarantee feasibility or stability for use in production environments.

General Approach#

Roughly divided into several threads, used for:

Logging
Target application instance management (potentially more than one thread)
Listening for IPC messages
Processing received IPC messages (main process)

This article focuses on the logging part.

Design Rationale#

Why dedicate a separate thread to logging? My consideration is that since it’s inherently a multi-threaded architecture, a unified logging module is necessary. If each thread prints independently, it’s highly likely that two threads could write to the file or output to the console simultaneously, causing log chaos.

Therefore, the general idea for logging is:

Define a queue to store log content and level.
Create a thread that continuously takes elements from the queue, deciding whether to print to the console or output to a file based on the set log level.
External components push log content to the queue.

Some Detailed Considerations#

Ensure portability by using the STL library as much as possible, e.g., using std::thread instead of pthread.
Ensure thread safety, requiring protection of relevant variables with mutexes or similar mechanisms.
Make the thread wait when the log queue is empty; thought of writing a blocking queue similar to Java’s BlockingQueue.
Specify a log level; only logs with a level meeting or exceeding this threshold will be saved or printed.
Implement variadic arguments via va_list to give the logging function a usage experience similar to sprintf.

Start Coding#

With the above approach, the overall coding becomes quite simple.

BlockingQueue#

~~Got lazy here, let DeepSeek write this part directly~~ To implement a multi-thread-safe blocking queue where calling front() blocks until another thread adds an element, we can combine a mutex (std::mutex) and a condition variable (std::condition_variable) to synchronize thread operations.

Code Implementation#

Mutex (`std::mutex`)#

All operations on the queue (push、front、pop、empty) need to acquire the lock first, ensuring only one thread can modify the queue at a time and avoiding data races.

Condition Variable (`std::condition_variable`)#

When front() is called and the queue is empty, the thread releases the lock and blocks via cv_.wait(), until another thread calls push() to add an element and wakes up one waiting thread via cv_.notify_one().
cv_.wait() needs to be used with std::unique_lock and automatically releases the lock while waiting to avoid deadlocks.
Uses a predicate check ([this] { return !queue_.empty(); }) to prevent spurious wakeups.

Element Retrieval and Removal#

front() returns a copy of the front element (not a reference), ensuring the caller gets the data after the queue’s lock is released, avoiding dangling references.
pop() must be called explicitly to remove the element, ensuring controllable queue state.

1
#include <queue>              // queue
2
#include <mutex>              // mutex
3
#include <condition_variable> // condition_variable
4

5
template<typename T>
6
class BlockingQueue {
7
public:
8
    // Add an element to the queue
9
    void push(const T& item) {
10
        std::lock_guard<std::mutex> lock(mtx_);
11
        queue_.push(item);
12
        cv_.notify_one(); // Notify one waiting thread
13
    }
14

15
    // Get the front element (blocks until queue is not empty)
16
    T front() {
17
        std::unique_lock<std::mutex> lock(mtx_);
18
        cv_.wait(lock, [this] { return !queue_.empty(); }); // Block until queue not empty
19
        return queue_.front();
20
    }
21

22
    // Get and remove the front element
23
    T take() {
24
        std::unique_lock<std::mutex> lock(mtx_);
25
        cv_.wait(lock, [this] { return !queue_.empty(); });
26
        T item = std::move(queue_.front()); // Use move semantics to avoid copy
27
        queue_.pop();
28
        return item;
29
    }
30

31
    // Remove the front element (requires external call, non-blocking)
32
    void pop() {
33
        std::lock_guard<std::mutex> lock(mtx_);
34
        if (!queue_.empty()) {
35
            queue_.pop();
36
        }
37
    }
38

39
    // Check if the queue is empty
40
    bool empty() const {
41
        std::lock_guard<std::mutex> lock(mtx_);
42
        return queue_.empty();
43
    }
44

45
private:
46
    mutable std::mutex mtx_;         // Mutex
47
    std::condition_variable cv_;     // Condition variable
48
    std::queue<T> queue_;            // Internal queue
49
};

Log Class#

Log.h#

1
#pragma once
2
#include <iostream>
3
#include <fstream>
4
#include <cstring>
5
#include <thread>
6
#include <chrono>
7
#include <mutex>
8
#include <cstdio>
9
#include <cstdarg>
10
#include <atomic>
11

12
#include "BlockingQueue.h"
13

14
enum LogLevel {
15
  LEVEL_VERBOSE,LEVEL_INFO,LEVEL_WARN,LEVEL_ERROR,LEVEL_FATAL,LEVEL_OFF
16
};
17

18
struct LogMsg {
19
  short m_LogLevel;
20
  std::string m_strTimestamp;
21
  std::string m_strLogMsg;
22
};
23

24
class Log {
25
private:
26
  std::ofstream m_ofLogFile;        // Log file output stream
27
  std::mutex m_lockFile;            // File operation mutex
28
  std::thread m_threadMain;         // Background log processing thread
29
  BlockingQueue<LogMsg> m_msgQueue; // Thread-safe blocking queue
30
  short m_levelLog, m_levelPrint;   // File and console log level thresholds
31
  std::atomic<bool> m_exit_requested{ false }; // Thread exit flag
32

33
  std::string getTime();            // Get current timestamp
34
  std::string level2str(short level, bool character_only); // Level to string
35
  void logThread();                 // Background thread function
36

37
public:
38
  Log(short default_loglevel = LEVEL_WARN, short default_printlevel = LEVEL_INFO);
39
  ~Log();
40
  void push(short level, const char* msg, ...); // Add log (supports formatting)
41
  void set_level(short loglevel, short printlevel); // Set log levels
42
  bool open(std::string filename);   // Open log file
43
  bool close();                      // Close log file
44
};

Log.cpp#

1
#include "Log.h"
2

3
std::string Log::getTime() {
4
  using sc = std::chrono::system_clock;
5
  std::time_t t = sc::to_time_t(sc::now());
6
  char buf[20];
7
#ifdef _WIN32
8
  std::tm timeinfo;
9
  localtime_s(&timeinfo,&t);
10
  sprintf_s(buf, "%04d.%02d.%02d-%02d:%02d:%02d",
11
    timeinfo.tm_year + 1900,
12
    timeinfo.tm_mon + 1,
13
    timeinfo.tm_mday,
14
    timeinfo.tm_hour,
15
    timeinfo.tm_min,
16
    timeinfo.tm_sec
17
  );
18
#else
19
  strftime(buf, 20, "%Y.%m.%d-%H:%M:%S", localtime(&t));
20
#endif
21
  return buf;
22
}
23

24
std::string Log::level2str(short level, bool character_only)
25
{
26
  switch (level) {
27
  case LEVEL_VERBOSE:
28
    return character_only ? "V" : "Verbose";
29
  case LEVEL_WARN:
30
    return character_only ? "W" : "Warning";
31
  case LEVEL_ERROR:
32
    return character_only ? "E" : "Error";
33
  case LEVEL_FATAL:
34
    return character_only ? "F" : "Fatal";
35
  }
36
  return character_only ? "I" : "Info";
37
}
38

39
void Log::logThread() {
40
  while (true) {
41
    LogMsg front = m_msgQueue.take(); // Block until a message arrives
42
    // Handle file writing
43
    if (front.m_LogLevel >= m_levelLog) {
44
      std::lock_guard<std::mutex> lock(m_lockFile); // RAII manage lock
45
      if (m_ofLogFile) {
46
        m_ofLogFile << front.m_strTimestamp << ' '
47
          << level2str(front.m_LogLevel, true) << ": "
48
          << front.m_strLogMsg << std::endl;
49
      }
50
    }
51
    // Handle console printing
52
    if (front.m_LogLevel >= m_levelPrint) {
53
      printf("%s %s: %s\n", front.m_strTimestamp.c_str(),
54
        level2str(front.m_LogLevel, true).c_str(),
55
        front.m_strLogMsg.c_str());
56
    }
57
    // Check exit condition: queue is empty and flag is true
58
    if (m_exit_requested.load() && m_msgQueue.empty()) break;
59
  }
60
  return;
61
}
62

63
Log::Log(short default_loglevel, short default_printlevel) {
64
  set_level(default_loglevel, default_printlevel);
65
  m_threadMain = std::thread(&Log::logThread, this);
66
}
67

68
Log::~Log() {
69
  m_exit_requested.store(true);
70
  m_msgQueue.push({ LEVEL_INFO, getTime(), "Exit." }); // Wake potentially blocked thread
71
  if (m_threadMain.joinable()) m_threadMain.join();
72
  close(); // Ensure file is closed
73
}
74

75
void Log::push(short level, const char* msg, ...) {
76
  va_list args;
77
  va_start(args, msg);
78
  const int len = vsnprintf(nullptr, 0, msg, args);
79
  va_end(args);
80

81
  if (len < 0) return;
82

83
  std::vector<char> buf(len + 1);
84

85
  va_start(args, msg);
86
  vsnprintf(buf.data(), buf.size(), msg, args);
87
  va_end(args);
88

89
  m_msgQueue.push({level,getTime(),buf.data()});
90
}
91

92
void Log::set_level(short loglevel, short printlevel)
93
{
94
  m_levelLog = loglevel;
95
  m_levelPrint = printlevel;
96
}
97

98
bool Log::open(std::string filename) {
99
  m_lockFile.lock();
100
  m_ofLogFile.open(filename.c_str(), std::ios::out);
101
  m_lockFile.unlock();
102
  return (bool)m_ofLogFile;
103
}
104

105
bool Log::close() {
106
  m_lockFile.lock();
107
  m_ofLogFile.close();
108
  m_lockFile.unlock();
109
  return false;
110
}

Explanation#

Class/Structure Explanation#

LogLevel Enum Defines log levels: VERBOSE, INFO, WARN, ERROR, FATAL, OFF。 OFF should not be used as a level for recorded logs, only for setting the threshold when needing to disable all logging.
LogMsg Struct Encapsulates a log message:

m_LogLevel: The log level.
m_strTimestamp: Timestamp string.
m_strLogMsg: The log content.

Member Variable Explanation#

Variable	Explanation
`m_ofLogFile`	File output stream for writing to the log file.
`m_lockFile`	Mutex protecting file operations.
`m_threadMain`	Background thread handling consumption of log messages.
`m_msgQueue`	Blocking queue storing pending log messages.
`m_levelLog`	Minimum log level for writing to file (messages with level >= this are recorded).
`m_levelPrint`	Minimum log level for printing to console.
`m_exit_requested`	Atomic flag controlling log thread exit.

Function Explanation#

Function	Explanation
`getTime`	Gets the current timestamp string (cross-platform implementation).
`level2str`	Converts log level to string (e.g., LEVEL_INFO → “I” or “Info”).
`logThread`	Background thread function: consumes queue messages, writes to file or prints.
Constructor	Initializes log levels, starts the background thread.
Destructor	Sets exit flag, waits for thread to finish, ensures remaining messages are processed.
`push`	Formats log message (supports variadic arguments) and pushes to the queue.
`set_level`	Dynamically sets the log and print levels.
`open`/`close`	Opens/closes the log file.

Complete code and test sample download: demo.zip

General Approach#

Design Rationale#

Some Detailed Considerations#

Start Coding#

BlockingQueue#

Code Implementation#

Mutex (std::mutex)#

Condition Variable (std::condition_variable)#

Element Retrieval and Removal#

Log Class#

Log.h#

Log.cpp#

Explanation#

Class/Structure Explanation#

Member Variable Explanation#

Function Explanation#

Mutex (`std::mutex`)#

Condition Variable (`std::condition_variable`)#