Question

我们公司正在重写C ++ 11中的大多数遗留C代码。（这也意味着我是一名学习C ++的C程序员）。我需要有关消息处理程序的建议。

我们有分布式系统 - 服务器进程通过TCP向客户端进程发送打包消息。

在C代码中，这是完成的： - 根据类型和子类型解析消息，这些消息始终是前2个字段

- call a handler as handler[type](Message *msg)

- handler creates temporary struct say, tmp_struct to hold the parsed values and .. 

- calls subhandler[type][subtype](tmp_struct)

每种类型/子类型只有一个处理程序。

转向C ++ 11和多线程环境。我的基本想法是 -

1）为每种类型/子类型组合注册处理器对象。这是
实际上是矢量矢量 - 矢量＆lt;矢量＆gt;

class MsgProcessor {

    // Factory function
    virtual Message *create();
    virtual Handler(Message *msg)
}

这将由不同的消息处理器继承

class AMsgProcessor : public MsgProcessor {

      Message *create() override();
      handler(Message *msg);
}

2）使用查找向量向量来获取处理器。使用重载的create（）工厂函数获取消息。这样我们就可以将实际消息和解析后的值保留在消息中。

3）现在有点破解，这条消息应该发送到其他线程进行繁重的处理。为了避免再次在向量中查找，在消息中添加了指向proc的指针。

class Message {
    const MsgProcessor *proc; // set to processor, 
                              // which we got from the first lookup
                              // to get factory function.
};

所以其他线程，只会做

Message->proc->Handler(Message *);

这看起来很糟糕，但希望是，这将有助于将消息处理程序与工厂分开。这是针对这种情况，当多个类型/子类型想要创建相同的消息，但以不同的方式处理它时。

我正在搜索这个并且遇到了：

http://www.drdobbs.com/cpp/message-handling-without-dependencies/184429055?pgno=1

它提供了一种将消息与处理程序完全分离的方法。但我想知道上面的简单方案是否会被认为是可接受的设计。这也是实现我想要的错误方式吗？

效率与速度一样，是此应用程序中最重要的要求。我们已经做了几个记忆Jumbs =＆gt; 2个向量+虚函数调用创建消息。到处理程序有两个顺从，我认为这从缓存的角度来看并不好。

Answer 1

虽然您的要求不清楚，但我认为我的设计可能正是您所寻找的。

查看http://coliru.stacked-crooked.com/a/f7f9d5e7d57e6261了解完全成熟的例子。

它有以下组件：

消息处理器IMessageProcessor的接口类。
表示Message的基类。 Message
注册类，其基本上是用于存储对应于（类型，子类型）对的消息处理器的单例。 Registrator。它将映射存储在unordered_map中。你也可以调整一下以获得更好的性能。 Registrator的所有公开API均受std::mutex保护。
MessageProcessor的具体实现。在这种情况下AMsgProcessor和BMsgProcessor。
simulate函数显示它们如何组合在一起。

此处也粘贴代码：

/*
 * http://stackoverflow.com/questions/40230555/efficient-message-factory-and-handler-in-c
 */

#include <iostream>
#include <vector>
#include <tuple>
#include <mutex>
#include <memory>
#include <cassert>
#include <unordered_map>

class Message;

class IMessageProcessor
{
public:
  virtual Message* create() = 0;
  virtual void handle_message(Message*) = 0;
  virtual ~IMessageProcessor() {};
};

/*
 * Base message class
 */
class Message
{
public:
  virtual void populate() = 0;
  virtual ~Message() {};
};

using Type = int;
using SubType = int;
using TypeCombo = std::pair<Type, SubType>;
using IMsgProcUptr = std::unique_ptr<IMessageProcessor>;

/*
 * Registrator class maintains all the registrations in an
 * unordered_map.
 * This class owns the MessageProcessor instance inside the
 * unordered_map.
 */
class Registrator
{
public:
  static Registrator* instance();

  // Diable other types of construction
  Registrator(const Registrator&) = delete;
  void operator=(const Registrator&) = delete;

public:
  // TypeCombo assumed to be cheap to copy
  template <typename ProcT, typename... Args>
  std::pair<bool, IMsgProcUptr> register_proc(TypeCombo typ, Args&&... args)
  {
    auto proc = std::make_unique<ProcT>(std::forward<Args>(args)...);
    bool ok;
    {
      std::lock_guard<std::mutex> _(lock_);
      std::tie(std::ignore, ok) = registrations_.insert(std::make_pair(typ, std::move(proc)));
    }
    return (ok == true) ? std::make_pair(true, nullptr) : 
                          // Return the heap allocated instance back
                          // to the caller if the insert failed.
                          // The caller now owns the Processor
                          std::make_pair(false, std::move(proc));
  }

  // Get the processor corresponding to TypeCombo
  // IMessageProcessor passed is non-owning pointer
  // i.e the caller SHOULD not delete it or own it
  std::pair<bool, IMessageProcessor*> processor(TypeCombo typ)
  {
    std::lock_guard<std::mutex> _(lock_);

    auto fitr = registrations_.find(typ);
    if (fitr == registrations_.end()) {
      return std::make_pair(false, nullptr);
    }
    return std::make_pair(true, fitr->second.get());
  }

  // TypeCombo assumed to be cheap to copy
  bool is_type_used(TypeCombo typ)
  {
    std::lock_guard<std::mutex> _(lock_);
    return registrations_.find(typ) != registrations_.end();
  }

  bool deregister_proc(TypeCombo typ)
  {
    std::lock_guard<std::mutex> _(lock_);
    return registrations_.erase(typ) == 1;
  }

private:
  Registrator() = default;

private:
  std::mutex lock_;
  /*
   * Should be replaced with a concurrent map if at all this
   * data structure is the main contention point (which I find
   * very unlikely).
   */
  struct HashTypeCombo
  {
  public:
    std::size_t operator()(const TypeCombo& typ) const noexcept
    {
      return std::hash<decltype(typ.first)>()(typ.first) ^ 
             std::hash<decltype(typ.second)>()(typ.second);
    }
  };

  std::unordered_map<TypeCombo, IMsgProcUptr, HashTypeCombo> registrations_;
};

Registrator* Registrator::instance()
{
  static Registrator inst;
  return &inst;
  /*
   * OR some other DCLP based instance creation
   * if lifetime or creation of static is an issue
   */
}


// Define some message processors

class AMsgProcessor final : public IMessageProcessor
{
public:
  class AMsg final : public Message 
  {
  public:
    void populate() override {
      std::cout << "Working on AMsg\n";
    }

    AMsg() = default;
    ~AMsg() = default;
  };

  Message* create() override
  {
    std::unique_ptr<AMsg> ptr(new AMsg);
    return ptr.release();
  }

  void handle_message(Message* msg) override
  {
    assert (msg);
    auto my_msg = static_cast<AMsg*>(msg);

    //.... process my_msg ?
    //.. probably being called in some other thread
    // Who owns the msg ??
    (void)my_msg; // only for suppressing warning

    delete my_msg;

    return;
  }

  ~AMsgProcessor();
};

AMsgProcessor::~AMsgProcessor()
{
}

class BMsgProcessor final : public IMessageProcessor
{
public:
  class BMsg final : public Message
  {
  public:
    void populate() override {
      std::cout << "Working on BMsg\n";
    }

    BMsg() = default;
    ~BMsg() = default;
  };

  Message* create() override
  {
    std::unique_ptr<BMsg> ptr(new BMsg);
    return ptr.release();
  }

  void handle_message(Message* msg) override
  {
    assert (msg);
    auto my_msg = static_cast<BMsg*>(msg);

    //.... process my_msg ?
    //.. probably being called in some other thread
    //Who owns the msg ??
    (void)my_msg; // only for suppressing warning

    delete my_msg;

    return;
  }

  ~BMsgProcessor();
};

BMsgProcessor::~BMsgProcessor()
{
}


TypeCombo read_from_network()
{
  return {1, 2};
}


struct ParsedData {
};

Message* populate_message(Message* msg, ParsedData& pdata)
{
  // Do something with the message
  // Calling a dummy populate method now
  msg->populate();
  (void)pdata;
  return msg;
}

void simulate()
{
  TypeCombo typ = read_from_network();
  bool ok;
  IMessageProcessor* proc = nullptr;

  std::tie(ok, proc) = Registrator::instance()->processor(typ);
  if (!ok) {
    std::cerr << "FATAL!!!" << std::endl;
    return;
  }

  ParsedData parsed_data;
  //..... populate parsed_data here ....

  proc->handle_message(populate_message(proc->create(), parsed_data));
  return;
}


int main() {

  /*
   * TODO: Not making use or checking the return types after calling register
   * its a must in production code!!
   */
  // Register AMsgProcessor
  Registrator::instance()->register_proc<AMsgProcessor>(std::make_pair(1, 1));
  Registrator::instance()->register_proc<BMsgProcessor>(std::make_pair(1, 2));

  simulate();

  return 0;
}

更新1

这里混淆的主要原因似乎是因为偶数系统的架构未知。

任何自尊的事件系统架构如下所示：

在套接字描述符上轮询的线程池。
用于处理与计时器相关的事件的线程池。
用于执行长时间阻塞作业的线程数量相对较少（取决于应用程序）。

所以，在你的情况下：

您将在执行epoll_wait或select或poll的主题上获得网络事件。
完全读取数据包并使用Registrator::get_processor调用获取处理器。注意：get_processor调用可以在没有任何锁定的情况下进行，如果可以保证基础unordered_map没有被修改，即一旦我们开始接收事件就不会进行新的插入。
使用获得的处理器，我们可以获得Message并填充它。
现在，这是我不确定你想要它的部分。此时，我们有processor，您可以从当前线程（即正在执行handle_message的线程）调用epoll_wait，或者通过发布作业将其调度到另一个线程（处理器）和消息）到接收队列的线程。

C ++中高效的消息工厂和处理程序

1 个答案: