C++ ASIO如何通过使用锁或无锁队列将完成处理程序传输到池的某个线程？

众所周知，Boost.ASIO可以从线程池

std:：vector

在已经存在的线程中运行完成处理程序。这允许我们消除创建和删除线程的开销。但是Boost.ASIO如何将下一个任务转移到现有线程中，是使用基于锁的队列（std:：mutex）还是使用无锁队列

他是如何做到这一点的

class session : public std::enable_shared_from_this<session>
{
public:
  session(tcp::socket socket) : socket_(std::move(socket))
  {}

  void do_read()
  {
    auto self(shared_from_this());
    socket_.async_read_some(boost::asio::buffer(data_, max_length),
        [this, self](boost::system::error_code ec, std::size_t length)
        {
          if (!ec)
          {
            for(auto &i : data_) std::cout << i;
            do_read();
          }
        });
  }

  tcp::socket socket_;
  enum { max_length = 1024 };
  char data_[max_length];
};

类会话：public std:：从\u中启用\u共享\u
{
公众：
会话（tcp:：套接字）：套接字（std:：移动（套接字））
{}
void do_read（）
{
自动自我（从_this（）共享_）；
套接字异步读取（boost:：asio:：buffer（数据，最大长度），
[this，self]（boost:：system:：error\u code ec，std:：size\u t length）
{
如果（！ec）
{
for（auto&i:data_uu）std:：cout do_read（）；
}
返回0；
}

---

将在类（会话）中创建lambda处理程序通过使用基于锁的队列或无锁队列可以转移到线程池的某些线程？

您是否认为无锁队列比基于锁的队列快？@Yakk是的，我的兴趣是基于这样一个事实，即无锁被剥夺了优先级反转的问题，并且印象是基于这个基准：more detail:那么你真正的问题是这里是否可以实现优先级反转？@EJP关于性能的真正问题。我也一直在想这一点。但实际上，我不知道这是否有区别，除非你总是使所有内核饱和，并且对任务具有最佳的线程亲和力

int main() {

    boost::asio::io_service io_service;
    std::vector<boost::thread> thr_grp_executors;
    unsigned int thread_num_acceptors = 2;

    // async non-blocking executors
    for(size_t i = 0; i < thread_num_executors; ++i)
        thr_grp_executors.emplace_back( 
                boost::bind(&boost::asio::io_service::run, &io_service) );

    // sync blocking acceptor
    tcp::acceptor a(io_service, tcp::endpoint(tcp::v4(), port));
    for (;;)
    {
        tcp::socket sock(io_service);
        a.accept(sock);
        std::make_shared<session>(std::move(socket_))->do_read();
    }

    return 0;

}