title: Boost asio TCP async server not async?
body: <p>I am using the code provided in the <a href="http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/example/cpp11/echo/async_tcp_echo_server.cpp" rel="nofollow">Boost example</a>.</p>
  
  <p>The server only accepts 1 connection at a time. This means, no new connections until the current one is closed.</p>
  
  <p>How to make the above code accept unlimited connections at the same time?</p>
  
  <pre><code>#include &lt;cstdlib&gt;
  #include &lt;iostream&gt;
  #include &lt;memory&gt;
  #include &lt;utility&gt;
  #include &lt;boost/asio.hpp&gt;
  
  using boost::asio::ip::tcp;
  
  class session
    : public std::enable_shared_from_this&lt;session&gt;
  {
  public:
    session(tcp::socket socket)
      : socket_(std::move(socket))
    {
    }
  
    void start()
    {
      do_read();
    }
  
  private:
    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)
            {
              boost::this_thread::sleep(boost::posix_time::milliseconds(10000));//sleep some time
              do_write(length);
            }
          });
    }
  
    void do_write(std::size_t length)
    {
      auto self(shared_from_this());
      boost::asio::async_write(socket_, boost::asio::buffer(data_, length),
          [this, self](boost::system::error_code ec, std::size_t /*length*/)
          {
            if (!ec)
            {
              do_read();
            }
          });
    }
  
    tcp::socket socket_;
    enum { max_length = 1024 };
    char data_[max_length];
  };
  
  class server
  {
  public:
    server(boost::asio::io_service&amp; io_service, short port)
      : acceptor_(io_service, tcp::endpoint(tcp::v4(), port)),
        socket_(io_service)
    {
      do_accept();
    }
  
  private:
    void do_accept()
    {
      acceptor_.async_accept(socket_,
          [this](boost::system::error_code ec)
          {
            if (!ec)
            {
              std::make_shared&lt;session&gt;(std::move(socket_))-&gt;start();
            }
  
            do_accept();
          });
    }
  
    tcp::acceptor acceptor_;
    tcp::socket socket_;
  };
  
  int main(int argc, char* argv[])
  {
    try
    {
      if (argc != 2)
      {
        std::cerr &lt;&lt; "Usage: async_tcp_echo_server &lt;port&gt;\n";
        return 1;
      }
  
      boost::asio::io_service io_service;
  
      server s(io_service, std::atoi(argv[1]));
  
      io_service.run();
    }
    catch (std::exception&amp; e)
    {
      std::cerr &lt;&lt; "Exception: " &lt;&lt; e.what() &lt;&lt; "\n";
    }
  
    return 0;
  }
  </code></pre>
  
  <p>As you see, the program waits for the sleep and it doesn't grab a second connection in the meantime.</p>