Потоки и асинхронность

while (true)
{
    auto socket = Socket(localhost, port);
    socket.wait_connection(); // Всё ещё есть блокировка
    socket.async_read([](auto &data)
    /*
     * Поток не блокируется, лямбда-функция будет вызвана
     * каждый раз после получения новых данных из сокета,
     * а основной поток пойдёт создавать новый сокет и
     * ждать новое соединение.
     */
    {
        socket.async_write(data, [](auto &socket)
        {
            if (socket.end_of_connection())
            socket.close();
        });
 
    });
}

#define _WIN32_WINNT 0x0501
    
#include <boost/asio/io_service.hpp>
#include <boost/thread/thread.hpp>
#include <boost/bind.hpp>
 
// функция, которая должна исполнять какую либо задачу.
// для примера пусть просто выводит текст в консоль
void myTask(const char* msg)
{
    std::cout << msg << '\n';
}
 
int main()
{
//-------------------------------------------------------------------
    // --- функциональность тред-пула
    
    boost::asio::io_service ioService;
    boost::thread_group threadpool;
    boost::asio::io_service::work work(ioService);
 
    // забиваем пулл рабочими тредами
    // обычно - по количеству ядер процессора
    const auto cpu_count 
        = boost::thread::hardware_concurrency();
 
    for(size_t n = 0; n!=cpu_count; ++n)
        threadpool.create_thread(
            boost::bind(&boost::asio::io_service::run, &ioService)
        );
//-------------------------------------------------------------------
    
    // нагружаем тред задачами
    for(size_t n = 0; n!=10;++n)
        ioService.post(boost::bind(myTask, "Hello World!"));
 
    // останавливаем пулл
    ioService.stop();
    
    // ждем когда все треды остановятся
    threadpool.join_all();    
}

#include <cstdlib>
#include <iostream>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
 
using boost::asio::ip::tcp;
 
class session
{
public:
  session(boost::asio::io_service& io_service)
    : socket_(io_service)
  {
  }
 
  tcp::socket& socket()
  {
    return socket_;
  }
 
  void start()
  {
    // отправляем запрос на чтение данных из сокета
    socket_.async_read_some(boost::asio::buffer(data_, max_length),
        boost::bind(&session::handle_read, this,
          boost::asio::placeholders::error,
          boost::asio::placeholders::bytes_transferred));
  }
 
  // обработчик события, что данные прочитаны (или ошибки)
  void handle_read(const boost::system::error_code& error,
      size_t bytes_transferred)
  {
    if (!error)
    {
      // отправляем обратно в сокет принятые данные
      boost::asio::async_write(socket_,
          boost::asio::buffer(data_, bytes_transferred),
          boost::bind(&session::handle_write, this,
            boost::asio::placeholders::error));
    }
    else
    {
      delete this;
    }
  }
 
  // обработчик события, что данные записаны (или ошибки)
  void handle_write(const boost::system::error_code& error)
  {
    if (!error)
    {
      // читаем следующую порцию данных
      socket_.async_read_some(boost::asio::buffer(data_, max_length),
          boost::bind(&session::handle_read, this,
            boost::asio::placeholders::error,
            boost::asio::placeholders::bytes_transferred));
    }
    else
    {
      delete this;
    }
  }
 
private:
  tcp::socket socket_;
  enum { max_length = 1024 };
  char data_[max_length];
};
 
class server
{
public:
  server(boost::asio::io_service& io_service, short port)
    : io_service_(io_service),
      acceptor_(io_service, tcp::endpoint(tcp::v4(), port))
  {
    session* new_session = new session(io_service_);
    // устанавливаем обработчик для первого подключения
    acceptor_.async_accept(new_session->socket(),
        boost::bind(&server::handle_accept, this, new_session,
          boost::asio::placeholders::error));
  }
 
  //  колбэк для  подключений
  void handle_accept(session* new_session,
      const boost::system::error_code& error)
  {
    if (!error)
    {
      new_session->start();
      new_session = new session(io_service_);
      // устанавливаем обработчик для следуего подключения
      acceptor_.async_accept(new_session->socket(),
          boost::bind(&server::handle_accept, this, new_session,
            boost::asio::placeholders::error));
    }
    else
    {
      delete new_session;
    }
  }
 
private:
  boost::asio::io_service& io_service_;
  tcp::acceptor acceptor_;
};
 
int main(int argc, char* argv[])
{
  try
  {
    if (argc != 2)
    {
      std::cerr << "Usage: async_tcp_echo_server <port>\n";
      return 1;
    }
 
    // создаем io_service - объект, внутри которго обрабатываюстя события
    boost::asio::io_service io_service;
 
    using namespace std; // For atoi.
    server s(io_service, atoi(argv[1]));
 
    // запускаем цикл обработки событий
    io_service.run();
  }
  catch (std::exception& e)
  {
    std::cerr << "Exception: " << e.what() << "\n";
  }
 
  return 0;
}