c++ - Boost Log 需要什么同步？

Question

我有一个从 WPF 和 C++\CLI 应用程序使用的 native C++ 库。我需要在可以与 WPF 应用程序中的日志记录合并的 native 库中实现日志记录。

我正在尝试使用 Boost LogV2 创建一个“可观察接收器”，我可以在其中注册一个监听器来传播 native 日志消息。

我的主要“关注点”之一是来自 Boost 示例的评论:“为简洁起见，我们跳过了实际的同步代码”。我不确定我应该做什么同步。

此外，使用同一个接收器的多个日志源会不会有任何问题？我想将具有不同属性的不同记录器添加到记录器(即从哪个模块引发日志消息)。

日志监听器

class ILogListener
{
public:
  virtual ~ILogListener() = default;
  virtual void onMessageLogged(const std::string& message) = 0;

protected:
  ILogListener() {};

private:
  // Disabling default copy constructor and default 
  // assignment operator.
  ILogListener(const ILogListener& copy) = delete;
  ILogListener& operator=(const ILogListener& copy) = delete;
};

class MyLogListener : public ILogListener
{
  void onMessageLogged(const std::string& message) override
  {
    std::cout << message << "\n";
  }
};

日志接收器

class ObservableLogSink : public sinks::basic_sink_backend< sinks::concurrent_feeding >
{
public:
  // The function is called for every log record to be written to log
  void consume(logging::record_view const& rec)
  {
    auto message = rec[expr::smessage];
    auto message_value = message.get();

    notifyListeners(message_value);
  }

  template <typename container, typename T>
  void addIfNotInContainer(container& c, T item)
  {
    typename container::iterator iter = find(c.begin(), c.end(), item);

    // Only add the listener if we don't have it in the container
    if (iter == c.end())
    {
      c.push_back(item);
    }
  }

  void notifyListeners(const std::string& message)
  {
    for (std::vector<ILogListener*>::iterator begin = listeners_.begin(), end = listeners_.end(); begin != end; ++begin)
    {
      (*begin)->onMessageLogged(message);
    }
  }

  void registerListener(ILogListener* listener)
  {
    addIfNotInContainer(listeners_, listener);
  }

  void removeListener(ILogListener* listener)
  {
    std::vector<ILogListener*>::iterator iter = find(listeners_.begin(), listeners_.end(), listener);

    // Only delete the listener if we have it in the container
    if (iter != listeners_.end())
    {
      listeners_.erase(iter);
    }
  }

private:
  std::vector<ILogListener*> listeners_;
};

记录器

class Logger
{
public:
  Logger() : sink_backend_(new ObservableLogSink())
  {
    init();
  }
  ~Logger(){}

  void registerListener(ILogListener* listener)
  {
    sink_backend_->registerListener(listener);
  }
  void removeListener(ILogListener* listener)
  {
    // TODO
  }

  void init()
  {
    logging::add_common_attributes();

    boost::shared_ptr< logging::core > core = logging::core::get();

    boost::shared_ptr<sinks::unlocked_sink<ObservableLogSink>> sink(new sinks::unlocked_sink<ObservableLogSink>(sink_backend_));

    core->add_sink(sink);
  }

  template <typename ... args >
  void log(args ... to_print)
  {

    logging::record rec = main_log_.open_record();
    if (rec)
    {
      logging::record_ostream strm(rec);

      print(strm, to_print...);

      render_log_.push_record(boost::move(rec));
    }
  }

private:
  boost::log::sources::logger_mt main_log_;

  boost::shared_ptr<ObservableLogSink> sink_backend_;

  template <typename T >
  void print(logging::record_ostream& stream, T only)
  {
    stream << only;
    stream.flush();
  }

  template <typename T, typename ... args >
  void print(logging::record_ostream& stream, T current, args... next)
  {
    stream << current << ' ';
    print(stream, next...);
  }
};

在行动

int main()
{
  Logger logger;

  std::unique_ptr<ILogListener> listener(new MyLogListener);

  logger.registerListener(listener.get());
  logger.log("Hello", "from", "logging");
}

Answer 1

如果您使用 unlocked_sink前端，就像您在代码中所做的那样，并在 example 中完成，然后可以从多个可能发出日志记录的线程并发调用后端。后端本身必须实现措施来保护其数据免受并发访问。通常，你需要一个互斥锁。有些情况下您不需要同步，例如当后端只是将日志记录转发给系统调用或另一个同步的 API 时； unlocked_sink主要用于此类情况。

但是，如果您的后端有需要保护的数据，更好的方法是使用 synchronous_sink 为您执行线程同步的前端。要表达您的后端需要外部同步的要求，您应该从 sinks::basic_sink_backend< sinks::synchronized_feeding > 派生。 .这样用户将无法使用 unlocked_sink前端与后端。

此外，如果您希望观察者接收格式化的消息而不仅仅是消息文本，您可能希望为您的后端启用格式化。您可以通过添加 formatted_records 来完成此操作到后端要求。

class ObservableLogSink :
    public sinks::basic_sink_backend<
        sinks::combine_requirements<
            sinks::synchronized_feeding,
            sinks::formatted_records
        >::type
    >
{
public:
    // Define types for characters and strings consumed by this backend
    typedef char char_type;
    typedef std::basic_string< char_type > string_type;

    // The function is called for every log record to be written to log
    void consume(logging::record_view const& rec,
        string_type const& formatted_message)
    {
        // Pass formatted_message to the observers
    }
};

然后您可以为接收器配置格式化程序 similar了解您如何处理其他水槽。