用 C++ 中的信号改变 std::thread 执行流程

Question

我有一个程序启动一个 std::thread 执行以下操作：睡眠 X，执行一个函数，终止。

create std::thread(Xms, &func)
  wait Xms
  then do func()
  end

我想知道是否可以例如向我的 std::thread 发送一个信号，以便立即中断睡眠并执行 func，然后退出。

我是否需要将信号发送到 std::thread::id 才能执行此操作？

我的线程以这种方式启动，带有一个 lambda 函数：

template<typename T, typename U>
void                          execAfter(T func, U params, const int ms)
{
  std::thread                 thread([=](){
      std::this_thread::sleep_for(std::chrono::milliseconds(ms));
      func(params);
    });
  thread.detach();
}

Answer 1

如果线程模型无法更改，则使用std::condition_variable 的wait_for 将是可行的方法。在下面的代码 sn-p 中，condition_variable 的使用被包装到一个类中，该类的对象必须跨线程共享。

#include <iostream>
#include <atomic>
#include <condition_variable>
#include <thread>
#include <chrono>

class BlockCondition
{
    private:
        mutable std::mutex m;
        std::atomic<bool> done;
        mutable std::condition_variable cv;
    public:
        BlockCondition()
        :
           m(),
           done(false),
           cv()
        {
        }
        void wait_for(int duration_ms)
        {
            std::unique_lock<std::mutex> l(m);
            int ms_waited(0);
            while ( !done.load() && ms_waited < duration_ms )
            {
               auto t_0(std::chrono::high_resolution_clock::now());
               cv.wait_for(l, std::chrono::milliseconds(duration_ms - ms_waited));
               auto t_1(std::chrono::high_resolution_clock::now());
               ms_waited += std::chrono::duration_cast<std::chrono::milliseconds>(t_1 - t_0).count();
            }
        }
        void release()
        {
            std::lock_guard<std::mutex> l(m);
            done.store(true);
            cv.notify_one();
        }
};

void delayed_func(BlockCondition* block)
{
    block->wait_for(1000);
    std::cout << "Hello actual work\n";
}

void abortSleepyFunction(BlockCondition* block)
{
    block->release();
}

void test_aborted()
{
    BlockCondition b();
    std::thread delayed_thread(delayed_func, &b);
    abortSleepyFunction(&b);
    delayed_thread.join();
}

void test_unaborted()
{
    BlockCondition b();
    std::thread delayed_thread(delayed_func, &b);
    delayed_thread.join();
}

int main()
{
    test_aborted();
    test_unaborted();
}

请注意，可能存在虚假唤醒，过早中止等待调用。考虑到这一点，我们计算实际等待的毫秒数并继续等待，直到设置完成标志。

Answer 2

正如 cmets 中所指出的，这首先不是解决问题的最明智的方法。由于实施适当的中断机制非常复杂且极易出错，因此以下是解决方法的建议：

不要在整个超时时间内休眠，而是简单地循环一个固定的小尺寸（例如 10 毫秒）的休眠，直到所需的持续时间过去。每次睡眠后，您检查一个原子标志是否请求中断。这是一个肮脏的解决方案，但却是最快的。

或者，为每个线程提供condition_variable 并在其上执行wait 而不是执行this_thread::sleep。通知条件变量指示中断请求。您可能仍然需要一个额外的标志来防止虚假唤醒，这样您就不会意外地过早返回。

Answer 3

好的，为了解决这个问题，我找到了一个新的实现，它受到您所有答案的启发，非常感谢。

首先我要做一个 BombHandler 项目，在主游戏项目中。它将有一个包含所有 Bomb 项目的属性。

这个 BombHandler 将是一个单例，包含一个将在线程中执行的 timerLoop() 函数（这样我只使用一个线程来处理 xxx 炸弹，这样更有效）

timerLoop() 将休眠(50) 然后通过整个 std::list 元素并调用 Bomb::incrTimer() 将其内部 _timer 属性无限增加 10ms，并检查必须爆炸的炸弹。

例如，当它们达到 2000 毫秒时，将调用 BombHandler.explode()，引爆炸弹并删除它。

如果另一个炸弹在范围内，Bomb::touchByFire() 将被调用，并将 Bomb 的内部属性 _timer 设置为 TIME_TO_EXPLODE (1950ms)。

然后它会在 50ms 后被 BombHandler::explode() 爆炸。

这不是一个很好的解决方案吗？

再次感谢您的回答！希望这能有所帮助。