Как использовать boost Asio в асинхронном режиме в несколько потоков?

Как использовать boost Asio в асинхронном режиме в несколько потоков? Может я был невнимателен, но насколько я понял, у всех потоков может быть единый io_context и в каждом потоке просто необходимо запустить run. Но когда я так делаю и вывожу в консоль id потока, все действия выполняются в одном потоке. Что я сделал не правильно, как запустить асинхронную обработку в несокольких потоках?

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

using boost::asio::ip::tcp;

class Session : public std::enable_shared_from_this<Session>{
private:
    tcp::socket sock;
    std::string message;
    uint16_t maxMessageLength;
private:
    Session(boost::asio::io_context& context, uint16_t maxMessageLength);
    void AfterRead(const boost::system::error_code&, size_t, std::function<void()>);
public:
    typedef std::shared_ptr<Session> SessionSharedPtr;
public:
    static SessionSharedPtr CreateNewSession(boost::asio::io_context& context, short messageLength = 2048);
    void ReceiveMessage(std::function<void()>,
                        const boost::system::error_code& err);
    void SendMessage(std::string& message,
                     std::function<void(const boost::system::error_code&, size_t)> handler,
                     const boost::system::error_code& err, size_t msgSize);
    std::string& GetMessage();
    tcp::socket& GetSocket();
    ~Session();
};

Session::Session(boost::asio::io_context &context, uint16_t maxMessageLength) : sock(context)
{
    this->maxMessageLength = maxMessageLength;
    message.resize(maxMessageLength);
}

Session::SessionSharedPtr Session::CreateNewSession(boost::asio::io_context &context, short messageLength) {
    return Session::SessionSharedPtr(new Session(context, messageLength));
}

void Session::ReceiveMessage(std::function<void()> handler,
                             const boost::system::error_code& err) {
    sock.async_read_some(boost::asio::buffer(message, maxMessageLength), std::bind(&Session::AfterRead,
                                                                                   this, std::placeholders::_1,
                                                                                   std::placeholders::_2, handler));
}

void Session::SendMessage(std::string& messageToSend,
                          std::function<void(const boost::system::error_code&, size_t)> handler,
                          const boost::system::error_code& err, size_t msgSize) {
    sock.async_write_some(boost::asio::buffer(messageToSend, maxMessageLength), handler);
}

Session::~Session() {
    sock.close();
}

std::string &Session::GetMessage() {
    return message;
}

tcp::socket &Session::GetSocket() {
    return sock;
}

void Session::AfterRead(const boost::system::error_code& err, size_t bytes, std::function<void()> handler) {
    handler();
}

boost::asio::io_context context;
tcp::acceptor acceptor(context, tcp::endpoint(tcp::v6(), 8000));

void accept(){
    auto session = Session::CreateNewSession(context);
    auto readFunc = std::bind(&Session::ReceiveMessage, session, [=](){
        std::cout << session->GetMessage();
        std::cout << std::this_thread::get_id << std::endl;
        accept();
    }, std::placeholders::_1);
    acceptor.async_accept(session->GetSocket(), readFunc);
    std::cout << std::this_thread::get_id << std::endl;
}


int main() {

    std::thread thread([](){
        accept();
        context.run();
    });
    accept();
    context.run();
    thread.join();
    return 0;
}