将数据写入客户端时，Boost 协程服务器崩溃

第1项质询

ba::async_write(socket_, ba::buffer(string("OK")), yield[ecw]);

这会调用未定义的行为，因为您传递了一个临时字符串作为缓冲区，但异步操作（根据定义）在调用返回之前不会完成。async_write

因此，缓冲区是对堆栈上已损坏的东西或现在存在于那里的任何东西的陈旧引用。

从逻辑上讲，发送缓冲区是对象的一部分，以获得更合适的生存期。或者，由于您正在执行协程，并且无论如何都要结束会话，因此只需使用 而不是 .selfwriteasync_write

第2项质询

因为未定义的行为是未定义的行为。任何事情都可能发生。

无人问津

• 而不是与 一起使用，或者与适当的完成条件一起使用。read_somereadtransfer_exactly(DATA_LEN_4)read_until

• 而不是你可以.buffer(reserved_string)dynamic_buffer

• 与其抛出神奇的字符串，不如抓住代码表示出现的情况：system_error

  try {
      timer_.expires_from_now(std::chrono::seconds(TIMEOUT_LIMIT));
  
      // read data
      std::string packet;
      auto received_len = ba::async_read(socket_,
              ba::dynamic_buffer(packet),
              ba::transfer_exactly(DATA_LEN_4), yield);
  
      assert(received_len == DATA_LEN_4); // guaranteed
  
      // write back "OK"
      ba::write(socket_, ba::buffer("OK"s));
  }
  catch (boost::system::system_error const& e) {
      if (e.code() == ba::error::operation_aborted)
          std::cout << "canceled (timeout)" << std::endl;
      else if (e.code() == ba::error::eof)
          std::cout << "eof" << std::endl;
      else throw std::runtime_error(e.code().message());
  }
  

• 所以，现在你可以用你的通用异常处理块来包装它：

  try {
      // ...
  } catch (std::exception const& e) {
      std::cout << "exception: " << std::quoted(e.what()) << std::endl;
  
      boost::system::error_code ignore;
      ba::async_write(socket_, ba::buffer(std::string(e.what())), yield[ignore]);
  
      socket_.close();
      timer_.cancel();
  }
  

  但！

  1. 通知你的客户是有用的，甚至是明智的，这似乎是非常可疑的
  2. 无论如何，在 Coro 中没有捕获异常都会破坏实例，因此您可以简单地让它逃脱self

定时器

• 时间完成已经表示计时器是过期还是取消：error_code

  while (socket_.is_open()) {
      boost::system::error_code ec;
      timer_.async_wait(yield[ec]);
  
      if (ba::error::operation_aborted != ec) // timer was not canceled
          socket_.close();
  }
  

• 但请注意，会话 coro 的常规返回路径不会调用 .这将导致套接字再保持打开<1秒，直到计时器到期。.cancel()time_

异常

如果你想让异常从coros中逃脱（你可以，你应该认为它发生了），你必须通过处理异常来改进线程循环：boost：：asio：：io_service：：run（）抛出的异常是否应该被捕获？

建议的服务器代码

结合 coros，大大简化了所有条件处理：

#include <iostream>
#include <iomanip>

#include <boost/thread/thread.hpp>
#include <boost/asio.hpp>
#include <boost/asio/spawn.hpp>
#include <boost/scope_exit.hpp>

using namespace std::literals;
namespace ba = boost::asio;
using ba::ip::tcp;

static constexpr unsigned short SERVER_PORT = 1234;
static constexpr std::size_t    DATA_LEN_4 = 4;
static constexpr auto           TIMEOUT_LIMIT = 1s;

struct session : public std::enable_shared_from_this<session>
{
    tcp::socket socket_;
    ba::steady_timer timer_;
    ba::strand<ba::io_context::executor_type> strand_;

    explicit session(ba::io_context& io_context, tcp::socket socket)
    : socket_(std::move(socket)),
      timer_(io_context),
      strand_(io_context.get_executor())
    { }

    void go() {
        ba::spawn(strand_, [this, self = shared_from_this()](ba::yield_context yield) {

            spawn(yield, [this, self](ba::yield_context yield) {
                timer_.expires_from_now(TIMEOUT_LIMIT);
                while (socket_.is_open()) {
                    boost::system::error_code ec;
                    timer_.async_wait(yield[ec]);
                    if (ba::error::operation_aborted != ec) // timer was not canceled
                        socket_.close();
                }
            });

            try {
                // read data
                std::string packet;
                ba::async_read(socket_,
                        ba::dynamic_buffer(packet),
                        ba::transfer_exactly(DATA_LEN_4), yield);

                // write back "OK"
                ba::write(socket_, ba::buffer("OK"s));
            }
            catch (boost::system::system_error const& e) {
                if (e.code() == ba::error::operation_aborted)
                    std::cout << "canceled (timeout)" << std::endl;
                else if (e.code() == ba::error::eof)
                    std::cout << "eof" << std::endl;
                else // throw std::runtime_error(e.code().message());
                    std::cout << "other: " << e.code().message() << std::endl;
            }

            socket_.close();
            timer_.cancel(); // cancel the other coro so we don't keep the session alive
        });
    }
};

int main() {
    ba::io_context io_context;

    ba::spawn(io_context, [&](ba::yield_context yield) {
        tcp::acceptor acceptor(io_context, tcp::endpoint(tcp::v4(), SERVER_PORT));

        for (;;) {
            boost::system::error_code ec;

            tcp::socket socket(io_context);
            acceptor.async_accept(socket, yield[ec]);
            if (!ec) 
                std::make_shared<session>(io_context, std::move(socket))->go();
        }
    });

    boost::thread_group tgroup;
    for (auto i = 0u; i < std::thread::hardware_concurrency(); ++i)
        tgroup.create_thread([&io_context] {
            for (;;) {
                try { io_context.run(); break; } // exited normally
                catch (std::exception const &e) { std::clog << "[eventloop] exception caught " << std::quoted(e.what()) << std::endl; } 
                catch (...)                     { std::clog << "[eventloop] unknown exception caught" << std::endl;                   } 
            }
        });

    tgroup.join_all();
}

使用随机客户端

将睡眠更改为随机，以便它有时有效，有时超时：

std::mt19937 prng { std::random_device{}() };
for (int i = 0; i < 4; i++) {
    ba::write(s, ba::buffer(std::string("A")));
    std::this_thread::sleep_for(std::uniform_int_distribution<>(200, 400)(prng) * 1ms);
}

打印在我的系统上：

1. received: OK
2. received: OK
3. received: OK
canceled (timeout)
4 exception read_some: End of file
5. received: OK
canceled (timeout)
6 exception read_some: End of file
7. received: OK
8. received: OK

看马，没有手

更简单一点，省略特殊情况的消息，实际上并没有太大变化：

ba::spawn(strand_, [this, self = shared_from_this()](ba::yield_context yield) {
    try {
        ba::steady_timer timer(strand_, TIMEOUT_LIMIT);
        timer.async_wait([this](error_code ec) {
            if (ba::error::operation_aborted != ec) 
                socket_.close();
            });

        std::string packet;
        ba::async_read(socket_,
                ba::dynamic_buffer(packet),
                ba::transfer_exactly(DATA_LEN_4), yield);

        ba::write(socket_, ba::buffer("OK"s));
    } catch(std::exception const& e) {
        std::clog << "error " << std::quoted(e.what()) << std::endl;
    }
});

请注意，我们甚至不再需要作为成员及其析构函数 在到达结束时，也会自动正确取消计时器 范围。timer_

输出实际上并没有太大变化：

1. received: OK
2. received: OK
3. received: OK
error "Operation canceled"
4 exception read_some: End of file
5. received: OK
6. received: OK
7. received: OK
error "Operation canceled"
8 exception read_some: End of file
error "Operation canceled"
9 exception read_some: End of file