Пример увеличения сервера asio datetime и использование std::async не работает

1. Да, пост нужен. Где бы std::async ни запускала лямбду, она по определению не находится в служебном потоке (который является неявной нитью).

2. Действительно, это так. Если вы употребите futureSink, вы снова увидите запуск деструктора: http://coliru.stacked-crooked.com/a/47d92eea20083e0f

Где исправить?

Прежде всего, std::async не является асинхронным. Это строго менее надежно std::thread (в лучшем случае).

Ваше будущее — глобальное, и оно не может хорошо работать с одновременными соединениями.

Поскольку на самом деле вы просто хотите объединить работу в необслуживаемом потоке (чтобы не блокировать ввод-вывод), я бы просто /сделал это/.

Прямой эфир на Колиру

#include <boost/asio.hpp>
#include <functional>
#include <iostream>
#include <memory>
#include <string>

namespace asio = boost::asio;
using namespace std::chrono_literals;
using namespace std::placeholders;
using asio::ip::tcp;

static asio::thread_pool pool(4); // how about some control over our threads

static std::string simulate_work() {
    std::this_thread::sleep_for(5s);
    return "Work simulation done";
}

class tcp_connection : public std::enable_shared_from_this<tcp_connection> {
  public:
    using pointer = std::shared_ptr<tcp_connection>;

    static pointer create(asio::io_context& io_context) { return pointer(new tcp_connection(io_context)); }

    tcp::socket& socket() { return socket_; }

    void start() {
        std::cerr << __PRETTY_FUNCTION__ << std::endl;
        auto self = shared_from_this();

        post(pool, [self, this]() {
            auto m = simulate_work();
            post(socket_.get_executor(),
                 [self, m = std::move(m)]() mutable { self->on_work_completed(std::move(m)); });
        });
    }

    ~tcp_connection() { std::cerr << __PRETTY_FUNCTION__ << std::endl; }

  private:
    tcp_connection(boost::asio::io_context& io_context) : socket_(io_context) {}

    void on_work_completed(std::string message) { // already on executor
        message_ = std::move(message);
        async_write(socket_, asio::buffer(message_),
                    bind(&tcp_connection::handle_write, shared_from_this(), _1, _2));
    }

    void handle_write(boost::system::error_code const& ec, size_t /*bytes_transferred*/) {
        std::cerr << ec.message() << ": " << __PRETTY_FUNCTION__ << std::endl;
    }

    tcp::socket socket_;
    std::string message_;
};

class tcp_server {
  public:
    tcp_server(asio::io_context& io_context)
        : io_context_(io_context)
        , acceptor_(io_context, {tcp::v4(), 1313}) {
        start_accept();
    }

  private:
    void start_accept() {
        tcp_connection::pointer new_connection = tcp_connection::create(io_context_);

        acceptor_.async_accept(new_connection->socket(),
                               bind(&tcp_server::handle_accept, this, new_connection, _1));
    }

    void handle_accept(tcp_connection::pointer new_connection, boost::system::error_code const& error) {
        if (!error)
            new_connection->start();

        start_accept();
    }

    asio::io_context& io_context_;
    tcp::acceptor     acceptor_;
};

int main() {
    try {
        boost::asio::io_context io_context;

        tcp_server server(io_context);
        io_context.run();
        pool.join();
    } catch (std::exception const& e) {
        std::cerr << e.what() << std::endl;
    }
}

БОНУС/ФАНСИЯ

Если вы хотите немного пофантазировать, вы можете добавить функцию инициации в стиле Asio async_simulate_work:

Прямой эфир на Колиру

#include <boost/asio.hpp>
#include <functional>
#include <iostream>
#include <memory>
#include <string>

namespace asio = boost::asio;
using namespace std::chrono_literals;
using namespace std::placeholders;
using asio::ip::tcp;

static std::string simulate_work() {
    std::this_thread::sleep_for(5s);
    return "Work simulation done";
}

template <typename Token> auto async_simulate_work(Token&& token) {
    return asio::async_initiate<Token, void(std::string)>( //
        [](auto handler) {
            std::thread(                             //
                [h = std::move(handler)]() mutable { //
                    std::move(h)(simulate_work());
                })
                .detach();
        },
        token);
}

class tcp_connection : public std::enable_shared_from_this<tcp_connection> {
  public:
    using pointer = std::shared_ptr<tcp_connection>;

    static pointer create(asio::io_context& io_context) { return pointer(new tcp_connection(io_context)); }

    tcp::socket& socket() { return socket_; }

    void start() {
        std::cerr << __PRETTY_FUNCTION__ << std::endl;
        auto self = shared_from_this();

        async_simulate_work(bind_executor(socket_.get_executor(), [self, this](std::string message) {
            message_ = std::move(message);
            async_write(socket_, asio::buffer(message_),
                        bind(&tcp_connection::handle_write, shared_from_this(), _1, _2));
        }));
    }

    ~tcp_connection() { std::cerr << __PRETTY_FUNCTION__ << std::endl; }

  private:
    tcp_connection(boost::asio::io_context& io_context) : socket_(io_context) {}

    void handle_write(boost::system::error_code const& ec, size_t /*bytes_transferred*/) {
        assert(socket_.get_executor().target<asio::io_context::executor_type>()->running_in_this_thread());
        std::cerr << ec.message() << ": " << __PRETTY_FUNCTION__ << std::endl;
    }

    tcp::socket socket_;
    std::string message_;
};

class tcp_server {
  public:
    tcp_server(asio::io_context& io_context)
        : io_context_(io_context)
        , acceptor_(io_context, {tcp::v4(), 1313}) {
        start_accept();
    }

  private:
    void start_accept() {
        tcp_connection::pointer new_connection = tcp_connection::create(io_context_);

        acceptor_.async_accept(new_connection->socket(),
                               bind(&tcp_server::handle_accept, this, new_connection, _1));
    }

    void handle_accept(tcp_connection::pointer new_connection, boost::system::error_code const& error) {
        if (!error)
            new_connection->start();

        start_accept();
    }

    asio::io_context& io_context_;
    tcp::acceptor     acceptor_;
};

int main() {
    try {
        boost::asio::io_context io_context;

        tcp_server server(io_context);
        io_context.run();
    } catch (std::exception const& e) {
        std::cerr << e.what() << std::endl;
    }
}

Еще одна локальная демонстрация: