如何在C++的低优先级线程中运行方法

How to run a method in a low priority thread in C++?

本文关键字：线程 运行 方法 优先级 C++      更新时间：2023-10-16

我正在使用gcc4.7 c ++和linux上的boost。

我有一个使用 boost：：signals2 的 EventDispatcher 类，如下所示。onUpdate()可以由多个线程调用

class EventDispather
{
public:
void subscribe(Listener l)
{
    _signal.connect(l)
}
void onUpdate(Data data)
{
    _signal(data);
}
private:
    boost::signals2::signal<void (Data)> _signal;
};

现在我想在类中添加一个信号来处理一些低优先级侦听器。当 onUpdate（） 执行时，它首先通知高优先级侦听器。然后是应该在低优先级线程中调用低优先级线程并立即返回。新代码如下所示：

class EventDispather
{
public:
void subscribe(Listener l, Priority priority=high)
{
    if(priority == high)
    {
        _signal.connect(l);
    }
    else
    {
        _signalLowPriority.connect(l);
    }
}
void onUpdate(Data data)
{
    _signal(data);
    //how to trigger _signalLowPriority in a low priority thread?
}
private:
    boost::signals2::signal<void (Data)> _signal;
    boost::signals2::signal<void (Data)> _signalLowPriority;
};

问题：

  • 如何在低优先级线程中触发_signalLowPriority()而不等待？
  • 另外，我不想每次onUpdate()执行时都创建一个新线程，而是重用单个线程..如何？

如果我的目标可以在使用标准库和/或提升时完成，那就太好了，但如果它真的有帮助，我可以使用任何其他库。

实现所需内容的最简单方法是将_signalLowPriority调用发布到 boost::asio::io_service ，该调用在单独的线程中运行。下面是一些（未经测试的）代码：

class EventDispather : enable_shared_from_this<EventDispather> // simplifies lifespan management, wrt async. slot invocations
{
  EventDispather() : work_(new io_service::work(io_)) // prevent io_serivce::run() from exiting when running out of work
  {
    auto self = shared_from_this();
    // capturing "self" (even without using it) ensures that this instance will outlive the async. "queue" that uses `io_` and `_signalLowPriority` members
    thread th([self, this]() { io_.run(); });
    set_priory_with_some_native_api(thread.native_handle());
    th.detach();
  }
  void stop()
  {
    // after work_ is reset, io_service::run() will process the pending functors and then exit; thus, the above lambda will get destroyed - along with its captured "self" shared_ptr
    work_.reset();
  }
  void onUpdate(Data data)
  {
    _signal(data);
    // if io_ is running in 1 thread, all _signalLowPriority invocations will be serialized 
    io_.post([data, this]() { _signalLowPriority(data); });
  }
private:
  io_service io_;
  shared_ptr<io_serive::work> work_;
  // add here all your signals etc...
};

注意：虽然_signalLowPriority是线程安全的，但它的插槽必须准备好在单独的线程中调用！

当然，你可以使用thread、enable_shared_from_this、shared_ptr std或boost。

相关文章：