Question

我想知道dispatch何时完成某些具体工作

service.dispatch(&some_work);

我想知道这一点，因为如果它已经完成，我需要重启some_work。

struct work
{
  std::shared_ptr<asio::io_service> io_service;
  bool ready;
  std::mutex m;
  template <class F>
  void do_some_work(F&& f)
  {
    if (io_service && ready) {
      m.lock();
      ready = false;
      m.unlock();
      io_service->dispatch([&f, this]() {
        f();
        m.lock();
        ready = true;
        m.unlock();
      });
    }
  }
  work(std::shared_ptr<asio::io_service> io_service)
    : io_service(io_service)
    , ready(true)
  {
  }
};

int
main()
{
  auto service = std::make_shared<asio::io_service>();
  auto w = std::make_shared<asio::io_service::work>(*service);
  std::thread t1([&] { service->run(); });

  work some_work{ service };
  for (;;) {
    some_work.do_some_work([] {
      std::cout << "Start long draw on thread: " << std::this_thread::get_id()
                << std::endl;
      std::this_thread::sleep_for(std::chrono::seconds(5));
      std::cout << "End long draw on thread: " << std::this_thread::get_id()
                << std::endl;
    });
  }
  w.reset();
  t1.join();
}

代码存在一些问题，例如，如果some_work超出范围，则正在运行的task仍会写入ready。

我想知道Asio中是否存在这样的东西？

Answer 1

对于终生问题，常见的习惯用法确实是使用共享指针，例如：

除此之外，完成处理程序已经该事件。所以你会这样做：

void my_async_loop() {
    auto This = shared_from_this();
    socket_.async_read(buffer(m_buffer, ..., 
        [=,This](error_code ec, size_t transferred) {
             if (!ec) {
                // do something
                my_async_loop();
             }
          }
      );
}

这将在前一个完成后重新安排（其他？）异步操作。

关于线程安全的主题，请参阅Why do I need strand per connection when using boost::asio?

如果`dispatched`或`post`已经完成，请在Asio中获取通知

1 个答案: