Question

我有以下代码：

#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/date_time.hpp>
#include <boost/function.hpp>
#include <boost/noncopyable.hpp>
#include <boost/smart_ptr/shared_ptr.hpp>
#include <boost/thread.hpp>

#include <map>
#include <utility>

namespace koicxx {

template <typename T>
class temp_storage : private boost::noncopyable
{
  typedef boost::shared_ptr<boost::asio::deadline_timer>                    shared_timer_t;
  typedef std::map<T, shared_timer_t>                                       timer_map_t;
  typedef std::pair<T, shared_timer_t>                                      timer_pair_t;
  typedef boost::function<void(const T&, const boost::system::error_code&)> callback_t;

public:
  temp_storage(boost::asio::io_service& io_service) :
    _io_service(io_service) {}

  bool add(const T& element, const boost::asio::deadline_timer::duration_type& timeout, callback_t callback = callback_t())
  {
    boost::lock_guard<boost::mutex> lock(_sync);

    const std::pair<timer_map_t::iterator, bool>& res =
      _internal_storage.insert(
        timer_pair_t(
          element
          , shared_timer_t(new boost::asio::deadline_timer(_io_service, timeout))
        ));

    if (!res.second)
    {
        return false;
    }

    const timer_map_t::iterator& itr = res.first;

    if (callback)
    {
      itr->second->async_wait(
        boost::bind(
          callback
          , itr->first
          , boost::asio::placeholders::error
        ));
    }

    itr->second->async_wait(
      boost::bind(
        &temp_storage::remove_callback
        , this
        , itr->first
        , boost::asio::placeholders::error
      ));

    return true;
  }

  bool remove(const T& element)
  {
    boost::lock_guard<boost::mutex> lock(_sync);

    const timer_map_t::iterator& itr = _internal_storage.find(element);
    if (itr == _internal_storage.end())
    {
        return false;
    }
    itr->second->cancel();

    _internal_storage.erase(itr);

    return true;
  }

  bool contains(const T& element)
  {
    boost::lock_guard<boost::mutex> lock(_sync);

    return _internal_storage.find(element) != _internal_storage.end();
  }

  void clear()
  {
    boost::lock_guard<boost::mutex> lock(_sync);

    for (timer_map_t::value_type& i : _internal_storage)
    {
        i.second->cancel();
    }

    _internal_storage.clear();
  }

private:
  void remove_callback(const T& element, const boost::system::error_code& e)
  {
    if (e == boost::asio::error::operation_aborted)
    {
        return;
    }
    remove(element);
  }

  boost::asio::io_service&  _io_service;
  timer_map_t               _internal_storage;
  boost::mutex              _sync;
};

} // namespace koicxx

int main()
{
  boost::asio::io_service io_service;
  koicxx::temp_storage<int> some_storage(io_service);
  some_storage.add(0, boost::posix_time::seconds(2));
  some_storage.add(1, boost::posix_time::seconds(3));
  some_storage.add(2, boost::posix_time::seconds(5));

  while (true)
  {
    if (some_storage.contains(0))
    {
      std::cout << 0 << ' ';
    }
    if (some_storage.contains(1))
    {
      std::cout << 1 << ' ';
    }
    if (some_storage.contains(2))
    {
      std::cout << 2 << ' ';
    }
    std::cout << '\n';

    boost::this_thread::sleep_for(boost::chrono::seconds(1));
  }
}

当我需要运行io_service时，为什么？我可以成为该类的io_service成员吗？这段代码有问题吗？

提前致谢。

Answer 1

你永远不会看到你的计时器到期。

调用async_wait时你所说的Asio是这样的：当计时器到期时，我希望你安排这个回调执行。请注意，＆＃39; schedule＆＃39;这并不意味着“立即执行”，而是“将其插入到准备执行的东西的队列中”。所述队列是io_service内部的一部分。在run上调用io_service将会阻止，直到所有待处理的工作都已安排并执行完毕。

这里的问题是run等待已经调度的两个回调（即那些已经准备好执行的回调）和那些仍在等待调度的回调（即那些你调用async_wait的回调但是计时器尚未到期的地方）。所以只需从主线程调用run就会阻塞，直到你的三个计时器都已过期，这可能不是你想要的。

您现在有两个选择：您可以打开第二个线程来呼叫run。这样可以工作，但你最终会得到两个主要没有做任何事情的线程（主线程，主要是在循环中休眠，而工作线程主要在run调用中休眠）。

更轻量级的方法是从循环中调用poll。与run不同，poll仅执行已经计划执行的回调，而不是那些仍在等待的回调。如果没有可用的回调，poll会立即返回而不是阻止：

template <typename T>
class temp_storage : private boost::noncopyable
{
public:
    void do_poll() {
         io_service_.poll();
    }
[...]
};

int main()
{
   [...]
   while (true)
   {
       [...]
       some_storage.do_poll();
       boost::this_thread::sleep_for(boost::chrono::seconds(1));
   }
}

当我需要运行io_service时，为什么

1 个答案: