【问题标题】:Setting limit on post queue size with Boost Asio?使用 Boost Asio 设置发布队列大小的限制?
【发布时间】:2012-07-25 14:52:25
【问题描述】:

我使用boost::asio::io_service 作为基本线程池。一些线程被添加到 io_service,主线程开始发布处理程序,工作线程开始运行处理程序,一切都结束了。到目前为止,一切都很好;与单线程代码相比,我得到了很好的加速。

但是,主线程有数百万内容要发布。它只是继续发布它们,比工作线程处理它们的速度要快得多。我没有达到 RAM 限制,但是将这么多东西排入队列仍然有点愚蠢。我想做的是为处理程序队列设置一个固定大小,如果队列已满,则使用 post() 块。

我在 Boost ASIO 文档中没有看到任何选项。这可能吗?

【问题讨论】:

    标签: c++ threadpool boost-asio


    【解决方案1】:

    我正在使用信号量来修复处理程序队列大小。下面的代码说明了这个解决方案:

    void Schedule(boost::function<void()> function)
    {
        semaphore.wait();
        io_service.post(boost::bind(&TaskWrapper, function));
    }
    
    void TaskWrapper(boost::function<void()> &function)
    {
        function();
        semaphore.post();
    }
    

    【讨论】:

      【解决方案2】:

      您可以将您的 lambda 封装在另一个 lambda 中,该 lambda 会负责计算“正在进行的”任务,然后在有太多正在进行的任务时等待发布。

      例子:

      #include <atomic>
      #include <chrono>
      #include <future>
      #include <iostream>
      #include <mutex>
      #include <thread>
      #include <vector>
      #include <boost/asio.hpp>
      
      class ThreadPool {
        using asio_worker = std::unique_ptr<boost::asio::io_service::work>;
        boost::asio::io_service service;
        asio_worker service_worker;
        std::vector<std::thread> grp;
        std::atomic<int> inProgress = 0;
        std::mutex mtx;
        std::condition_variable busy;
      public:
        ThreadPool(int threads) : service(), service_worker(new asio_worker::element_type(service)) {
          for (int i = 0; i < threads; ++i) {
            grp.emplace_back([this] { service.run(); });
          }
        }
      
        template<typename F>
        void enqueue(F && f) {
          std::unique_lock<std::mutex> lock(mtx);
          // limit queue depth = number of threads
          while (inProgress >= grp.size()) {
            busy.wait(lock);
          }
          inProgress++;
          service.post([this, f = std::forward<F>(f)]{
            try {
              f();
            }
            catch (...) {
              inProgress--;
              busy.notify_one();
              throw;
            }
            inProgress--;
            busy.notify_one();
          });
        }
      
        ~ThreadPool() {
          service_worker.reset();
          for (auto& t : grp)
            if (t.joinable())
              t.join();
          service.stop();
        }
      };
      
      int main() {
        std::unique_ptr<ThreadPool> pool(new ThreadPool(4));
        for (int i = 1; i <= 20; ++i) {
          pool->enqueue([i] {
            std::string s("Hello from task ");
            s += std::to_string(i) + "\n";
            std::cout << s;
            std::this_thread::sleep_for(std::chrono::seconds(1));
          });
        }
        std::cout << "All tasks queued.\n";
        pool.reset(); // wait for all tasks to complete
        std::cout << "Done.\n";
      }
      

      输出:

      Hello from task 3
      Hello from task 4
      Hello from task 2
      Hello from task 1
      Hello from task 5
      Hello from task 7
      Hello from task 6
      Hello from task 8
      Hello from task 9
      Hello from task 10
      Hello from task 11
      Hello from task 12
      Hello from task 13
      Hello from task 14
      Hello from task 15
      Hello from task 16
      Hello from task 17
      Hello from task 18
      All tasks queued.
      Hello from task 19
      Hello from task 20
      Done.
      

      【讨论】:

        【解决方案3】:

        您可以使用 strand 对象来放置事件并在 main 中放置延迟吗?发布所有工作后,您的程序是否退出?如果是这样,您可以使用工作对象,它可以让您更好地控制 io_service 何时停止。

        您总是可以主要检查线程的状态并让它等到一个空闲或类似的东西。

        //链接

        http://www.boost.org/doc/libs/1_40_0/doc/html/boost_asio/reference/io_service__strand.html

        http://www.boost.org/doc/libs/1_40_0/doc/html/boost_asio/reference/io_service.html

        //example from the second link
        boost::asio::io_service io_service;
        boost::asio::io_service::work work(io_service);
        

        希望这会有所帮助。

        【讨论】:

        • 问题不在于io_service在完成工作之前就停止了——我们知道删除work对象以使io_service优雅地停止。问题是io_service 让太多任务累积。我们希望以不涉及轮询创建任务的线程部分的方式限制未分配任务的数量,因此我们的问题是是否可以阻止 poll()。
        【解决方案4】:

        也许可以尝试降低主线程的优先级,这样一旦工作线程忙起来,他们就会饿死主线程和系统自我限制。

        【讨论】:

          猜你喜欢
          • 1970-01-01
          • 1970-01-01
          • 1970-01-01
          • 2016-10-30
          • 2020-09-02
          • 2012-01-13
          • 2018-06-24
          • 2019-04-02
          • 2012-06-18
          相关资源
          最近更新 更多