调用available（）方法on _stream.lowest_layer（）查看有多少字节可用会导致错误的文件描述符异常。
这意味着套接字变得无效，例如，因为它被关闭。
为了检查问题的其余部分，我使用BARE最小代码使您的代码自包含：

Live On Coliru

#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>
#include <iostream>
namespace asio = boost::asio;
namespace ssl = asio::ssl;
using namespace std::chrono_literals;
using error_code = boost::system::error_code;
using asio::ip::tcp;

static ssl::context s_ctx{ssl::context::sslv23_server};

struct SomeClass : std::enable_shared_from_this<SomeClass> {
    SomeClass(tcp::socket&& s) : _stream(std::move(s), s_ctx) {}

    void start() {
        _stream.async_handshake(ssl::stream_base::server, [this, self = shared_from_this()](error_code ec) {
            std::cout << "Handshake: " << ec.message() << std::endl;
            if (!ec)
                read("\n");
        });
    }

  private:
    asio::streambuf                     _recBuf;
    ssl::stream<tcp::socket>            _stream;
    asio::strand<asio::any_io_executor> _readStrand{_stream.get_executor()};
    using String = std::string;

    void read(String const& delim) {
        asio::async_read_until(
            _stream, _recBuf, delim,
            bind_executor( //
                _readStrand, [this, delim, self = shared_from_this()](error_code const& ec, size_t bytes) {
                    if (!ec || (ec == asio::error::eof && bytes)) {
                        if (bytes <= delim.size()) {
                            return; // TODO review?!
                        }

                        String data(asio::buffers_begin(_recBuf.data()),
                                    asio::buffers_begin(_recBuf.data()) + (bytes - delim.size()));
                        _recBuf.consume(bytes);

                        std::cout << "Received:  " << quoted(data) << std::endl;
                        std::cout << "Available: " << _recBuf.size() << "/"
                                  << _stream.lowest_layer().available() << std::endl;

                        read(delim);
                    } else if (ec == asio::error::operation_aborted) {

                    } else {
                    }
                }));
    }
};

void accept_loop(tcp::acceptor& acc) {
    acc.async_accept(make_strand(acc.get_executor()), [&acc](error_code ec, tcp::socket s) {
        if (!ec) {
            std::cout << "Accepted from " << s.remote_endpoint() << std::endl;
            std::make_shared<SomeClass>(std::move(s))->start();
            accept_loop(acc);
        }
    });
}

int main() {
    s_ctx.set_default_verify_paths();
    s_ctx.use_private_key_file("server.pem", ssl::context::pem);
    s_ctx.use_certificate_file("server.pem", ssl::context::pem);

    asio::io_context ioc(1);
    tcp::acceptor acc(ioc, {{}, 6443});
    accept_loop(acc);

    ioc.run();
    ioc.run_for(30s);
}

字符串
使用server.pem和客户端

openssl s_client -connect 127.0.0.1:6443 <<< $'FIRST\nSECOND\nTHIRD\nFOURTH'

型
精确显示预期的

Accepted from 127.0.0.1:40198
Handshake: Success
Received:  "FIRST"
Available: 20/0
Received:  "SECOND"
Available: 13/0
Received:  "THIRD"
Available: 7/0
Received:  "FOURTH"
Available: 0/0

型
任何剩下的批评都将是

• 不是特别有效的字符串提取
• bind_executor，它比首先将套接字与串相关联要差（在我的代码中，我已经这样做了，所以会话类（SomeClass）中的整个串都是冗余的）
• 事实上，你比较错误代码，特别是在不同的类别-这将不起作用。相反，比较asio::error::operation_aborted或实际上对应的error_condition，如果可用（阅读这里了解更多：测试特定的错误条件）
• 当bytes <= delim.size()时，静默地中断读循环（以及可能的连接）。当客户端发送空消息时，这看起来像“刚刚挂断”。
• 忘记处理部分成功（例如，在中断时）-在这种特殊情况下，您可能希望在截断消息之前检查中断的存在。（我的代码还没有做这部分）