我实际上正在寻找一种在我的 C++ 中进行异步和线程安全日志记录的方法。
我已经探索过线程安全的日志记录解决方案，例如 log4cpp、log4cxx、Boost:log 或 rlog，但似乎它们都使用互斥锁。据我所知，互斥锁是一种同步解决方案，这意味着所有线程在尝试写入消息时都会被锁定，而其他线程则会锁定。
你知道解决办法吗？
【问题讨论】：
标签： c++ multithreading logging asynchronous thread-safety
我认为您的说法是错误的：使用互斥锁不一定等同于同步解决方案。是的，Mutex 用于同步控制，但它可以用于许多不同的事情。例如，我们可以在生产者消费者队列中使用互斥锁，而日志记录仍在异步发生。
老实说，我还没有研究过这些日志库的实现，但是制作一个异步 appender（对于 log4j 之类的 lib）应该是可行的，该 appender 记录器写入生产者消费者队列，另一个工作线程负责写入文件（甚至委托给另一个附加程序），以防未提供。
编辑： 刚刚在 log4cxx 中进行了简短的扫描，它确实提供了一个 AsyncAppender，它执行我的建议：缓冲传入的日志事件，并异步委托给附加的 appender。
【讨论】：
我建议通过仅使用一个线程进行日志记录来避免该问题。为了将必要的数据传递到日志，您可以使用无锁 fifo 队列（线程安全，只要生产者和消费者严格分开并且每个角色只有一个线程 - 因此每个生产者都需要一个队列。）
包含快速无锁队列示例：
队列.h：
#ifndef QUEUE_H
#define QUEUE_H
template<typename T> class Queue
{
public:
virtual void Enqueue(const T &element) = 0;
virtual T Dequeue() = 0;
virtual bool Empty() = 0;
};
hybridqueue.h：
#ifndef HYBRIDQUEUE_H
#define HYBRIDQUEUE_H
#include "queue.h"
template <typename T, int size> class HybridQueue : public Queue<T>
{
public:
virtual bool Empty();
virtual T Dequeue();
virtual void Enqueue(const T& element);
HybridQueue();
virtual ~HybridQueue();
private:
struct ItemList
{
int start;
T list[size];
int end;
ItemList volatile * volatile next;
};
ItemList volatile * volatile start;
char filler[256];
ItemList volatile * volatile end;
};
/**
* Implementation
*
*/
#include <stdio.h>
template <typename T, int size> bool HybridQueue<T, size>::Empty()
{
return (this->start == this->end) && (this->start->start == this->start->end);
}
template <typename T, int size> T HybridQueue<T, size>::Dequeue()
{
if(this->Empty())
{
return NULL;
}
if(this->start->start >= size)
{
ItemList volatile * volatile old;
old = this->start;
this->start = this->start->next;
delete old;
}
T tmp;
tmp = this->start->list[this->start->start];
this->start->start++;
return tmp;
}
template <typename T, int size> void HybridQueue<T, size>::Enqueue(const T& element)
{
if(this->end->end >= size) {
this->end->next = new ItemList();
this->end->next->start = 0;
this->end->next->list[0] = element;
this->end->next->end = 1;
this->end = this->end->next;
}
else
{
this->end->list[this->end->end] = element;
this->end->end++;
}
}
template <typename T, int size> HybridQueue<T, size>::HybridQueue()
{
this->start = this->end = new ItemList();
this->start->start = this->start->end = 0;
}
template <typename T, int size> HybridQueue<T, size>::~HybridQueue()
{
}
#endif // HYBRIDQUEUE_H
【讨论】：
如果我的问题正确，您担心在记录器的关键部分执行 I/O 操作（可能写入文件）。
Boost:log 允许您定义自定义写入器对象。您可以定义 operator() 来调用异步 I/O 或将消息传递给您的日志线程（正在执行 I/O）。
http://www.torjo.com/log2/doc/html/workflow.html#workflow_2b
【讨论】：
据我所知，没有图书馆会这样做 - 这太复杂了。您必须自己动手，这是我刚刚想到的一个想法，创建一个每个线程的日志文件，确保每个条目中的第一项是时间戳，然后在运行和排序之后合并日志（按时间戳) 以获取最终的日志文件。
您可以使用一些线程本地存储（比如FILE 句柄AFAIK，它不可能在线程本地存储中存储流对象）并在每个日志行上查找此句柄并写入特定的文件。
所有这些复杂性与锁定互斥锁？我不知道您的应用程序的性能要求，但如果它很敏感 - 为什么要记录（过度）？想想其他无需登录即可获得所需信息的方法？
另外要考虑的另一件事是尽可能少地使用互斥锁，即首先构建您的日志条目，然后在写入文件之前获取锁。
【讨论】：
在 Windows 程序中，我们使用用户定义的 Windows 消息。首先，为堆上的日志条目分配内存。然后调用 PostMessage，指针为 LPARAM，记录大小为 WPARAM。接收器窗口提取记录、显示并将其保存在日志文件中。然后 PostMessage 返回，分配的内存被发送者释放。这种方法是线程安全的，您不必使用互斥锁。并发由 Windows 的消息队列机制处理。 不是很优雅，但很有效。
【讨论】：
无锁算法不一定是最快的。定义你的界限。有多少个线程用于记录？一次日志操作最多会写入多少？
由于阻塞/唤醒线程，I/O 绑定操作比线程上下文切换慢得多。使用 10 个写线程的无锁/自旋锁算法会给 CPU 带来沉重的负担。
简而言之，在写入文件时阻塞其他线程。
【讨论】：