Question

假设我们有一个应用程序运行多个网络客户端进行循环：发送请求，然后暂停指定的时间，然后再次。

示例（并非所有代码）：

#define WAIT_INTERVAL 1000

class client()
{
public:
    explicit client(boost::asio::io_service & io_service)
        : io_service_(io_service) 
    { 
        working_ = true; 
    };

    run(boost::asio::yield_context t_yield) 
    {
        while (working_) {
            // async wait
            boost::asio::deadline_timer timer(io_service_, boost::posix::milliseconds(WAIT_INTERVAL));

            timer.async_wait(t_yield);

            do_work();
        }
    };

private:
    void do_work()
    {
        // make work
    }

    bool working_{ false };
    boost::asio::io_service & io_service_;
}

class app()
{
public:
    // code omitted

    prepare(size_t number_of_clients)
    {
        clients_.reserve(number_of_clients);

        for (size_t i = 0; i < number_of_clients; ++i) 
        {
            clients_.emplace_back(io_service_);
        }
    }

    run()
    {
        for (auto & client : clients_) 
        {
            boost::asio::spawn(io_service_, [&client](boost::asio::yield_context t_yield)
            {
                client.run(t_yield);
            });
        }
    }

private:
    boost::asio::io_service io_service_;
    std::vector<client> clients_;
}

问题是：当运行许多客户端（例如100个左右）时，deadline_timer实际上等待了几秒钟，不是接近1000毫秒，而是大约9000毫秒甚至更多。

如何避免这种情况或如何重写程序，以便每个客户端等待给定的等待间隔加减一些差异？

Answer 1

只是不等待让计时器到期，但是在计时器到期时传递一个处理程序。在ASIO应用程序中，唯一的阻止调用应该是io_service::run()。

使用许多boost :: asio :: deadline_timer

1 个答案: