c++ - 使用 boost.signals2 在线程之间传递数据

Question

对于这个模棱两可的标题，我深表歉意，但我会在这里尝试进一步详细说明：

我有一个应用程序，其中包括（除其他外）一个控件和 TCP 服务器类。TCP 和控制类之间的通信是通过这个实现完成的：

#include <boost/signals2.hpp>                                                                        

// T - Observable object type                                                                        
// S - Function signature                                                                            
template <class T, typename S> class observer {                                                      
        using F = std::function<S>;                                                                  

      public:                                                                                        
        void register_notifier(T &obj, F f)                                                          
        {                                                                                            
                connection_ = obj.connect_notifier(std::forward<F>(f));                              
        }                                                                                            

      protected:                                                                                     
        boost::signals2::scoped_connection connection_;                                              
};                                                                                                   

// S - Function signature                                                                            
template <typename S> class observable {                                                             
      public:                                                                                        
        boost::signals2::scoped_connection connect_notifier(std::function<S> f)                      
        {                                                                                            
                return notify.connect(std::move(f));                                                 
        }                                                                                            

      protected:                                                                                     
        boost::signals2::signal<S> notify;                                                           
};

其中 TCP 服务器类是 observable，控制类是观察者。

TCP 服务器运行在与控制类不同的线程上，并使用 boost::asio::async_read。每当收到消息时，服务器对象都会通过'notify'成员发送通知，从而触发控件类中注册的回调，然后等待读取下一条消息。

问题是我需要以某种方式安全有效地存储当前存储在 TCP 服务器缓冲区中的数据，并将其传递给控制类，然后再被下一条消息覆盖。

IE ：

inline void ctl::tcp::server::handle_data_read(/* ... */)                                  
{                                                                                                    
        if (!error) {                                                                                 
                /* .... */
                notify(/* ? */); // Using a pointer to the buffer
                                 // would obviously fail as it
                                 // is overridden in the next read                    
        }
        /* .... */                                                                                            
}

到目前为止，这些是我对解决方案的想法：

1. 分配堆内存并使用 unique_ptr 传递指向它的指针，但我不确定 boost.signals2 是否具有移动感知功能。
2. 使用无序映射（对象之间共享），将整数索引映射到数据类型的 unique_ptr ( std::unordered_map<int, std::unique_ptr<data_type>>)，然后只传递元素的索引，并在控件类回调中“弹出”它，但感觉就像一个矫枉过正。

我真正想要的是一个简单而有效的解决方案的想法，以在线程之间传递每条消息的 TCP 缓冲区内容。

请注意，如果完全错误，我也愿意接受重新设计对象之间的通信方法的建议。

标签： c++boostc++14