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

Question

众所周知，Boost.ASIO可以在线程池std::vector<boost::thread>已经存在的线程中运行完成处理程序。这允许我们消除创建和删除线程的开销。但是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];
};

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;

}

通过使用基于锁的队列或无锁队列，将类（会话）中的lambda-handler转移到某些线程 - 池线程？