Question

class UDP_Receiver
{
public:
    udp_receiver((boost::asio::io_service& io_service) :
    idle_work_(io_service_),
    socket_(new boost::asio::ip::udp::socket(io_service))
    {
    }

    void start_receive()
    {
        socket_.async_receive_from(boost::asio::buffer(buffer, buffer.size()), 
                                    remote_endpoint_,
                                    [&](boost::system::error_code const& ec, std::size_t N) 
        {
            if (!ec.value())
            {
                std::unique_ptr<char[]> custom_buffer_ptr(new char[N], std::default_delete<char[]>());
                std::memcopy(custom_buffer, &buffer.data(), N);

                do_custom_stuff(std::move(custom_buffer), N);
            }
        }
    }

private:
    std::array<char, 6000> buffer;
    boost::asio::ip::udp::socket socket_;
    boost::asio::io_service::work idle_work_;
};

int main()
{
  std::size_t numberOfThreads = 2;
  std::vector<std::thread> workerThreads;

  boost::asio::io_service io_service_;

  UDP_Receiver udp_receiver(io_service_);

  for(size_t i = 0; i < numberOfThreads; i++) {
    workerThreads.push_back(std::thread([&] { io_service().run(); }));
  }

  for(auto &thread : workerThreads){
    thread.join();
  }
}

我的场景中的io_service由两个线程处理。现在我调查一个问题，例如，如果直接接收两个udp消息，则缓冲区只保存最后一条消息。

因此删除了一条消息。是否有线程安全的方式保证所有收到的udp数据包都被缓冲并单独记忆没有消息丢失？

例如stream_buffer是解决方案吗？

Answer 1

使用缓冲区集合不是一个更好的主意 - 类似于std::vector<std::array<char, 6000>> bufferCollection，然后使用start_receive()中的锁来保护它。这样，您可以安全地填充它。如果要使用某个键来区分缓冲区，可以使用std::map。

在多线程场景中提升asio async_receive_from缓冲区消息

1 个答案: