超时后如何终止函数调用？

Question

假设我有一个 foo() 函数。例如，我希望它运行 5 秒，然后必须取消它并继续执行程序的其余部分。

代码sn-ps：

int main() {
    // Blah blah
    foo(); // Running in 5 sec only
    // After 5 sec, came here and finished
}

参考：在 StackOverflow 上搜索了一段时间后，我发现这是我需要但用 python 编写的：Timeout on a function call。

signal.h 和 unistd.h 可以关联。

Answer 1

这可以通过线程来实现。从 C++20 开始，这将相当简单：

{
    std::jthread t([](std::stop_token stoken) {
        while(!stoken.stop_requested()) {
            // do things that are not infinite, or are interruptible
        }
    });

    using namespace std::chrono_literals;
    std::this_thread::sleep_for(5s);
}

请注意，与操作系统的许多交互都会导致进程被“阻塞”。一个例子是 POSIX 函数listen，它等待传入的连接。如果线程被阻塞，那么它将无法进行下一次迭代。

不幸的是，C++ 标准没有指定此类特定于平台的调用是否应被停止请求中断。您需要使用特定于平台的方法来确保发生这种情况。通常，可以将信号配置为中断阻塞系统调用。对于listen，一个选项是连接到等待套接字。

Answer 2

在 C++ 中无法统一执行此操作。当您使用特定于操作系统的 API 时，有一些方法可以取得一定程度的成功，但是这一切都变得非常麻烦。

您可以在 *nix 中使用的基本思想是 alarm() 系统调用和 setjmp/longjmp C 函数的组合。

一个（伪）代码：

std::jmp_buf jump_buffer;

void alarm_handle(int ) {
    longjmp(jump_buffer);
}

int main() {
   signal(SIGALRM, alarm_handle); 
    alarm(5);
    if (setjmp(jump_buffer)) {
        foo(); // Running in 5 sec only
     } else {
        // After 5 sec, came here and finished
        // if we are here, foo timed out
     } 
}

这一切都非常脆弱和不稳定（即长跳转不能很好地适应 C++ 对象的生命周期），但如果你知道你在做什么，这可能会起作用。

Answer 3

完全标准的 C++11

#include <iostream>
#include <thread>         // std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds

using namespace std;

// stop flag
bool stopfoo;

// function to run until stopped
void foo()
{
    while( ! stopfoo )
    {
        // replace with something useful
        std::this_thread::sleep_for (std::chrono::seconds(1));
        std::cout << "still working!\n";
    }
    std::cout "stopped\n";
}

// function to call a top after 5 seconds
void timer()
{
    std::this_thread::sleep_for (std::chrono::seconds( 5 ));
    stopfoo = true;
}

int main()
{
    // initialize stop flag
    stopfoo = false;

    // start timer in its own thread
    std::thread t (timer);

    // start worker in main thread
    foo();

    return 0;
}

这与线程安全停止标志相同（不是必需的，但对于更复杂的情况来说是一种很好的做法）

#include <iostream>
#include <thread>         // std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds
#include <mutex>

using namespace std;

class cFlagThreadSafe
{
public:
    void set()
    {
        lock_guard<mutex> l(myMtx);
        myFlag = true;
    }
    void unset()
    {
        lock_guard<mutex> l(myMtx);
        myFlag = false;
    }
    bool get()
    {
         lock_guard<mutex> l(myMtx);
         return myFlag;
    }
private:
    bool myFlag;
    mutex myMtx;
};

// stop flag
cFlagThreadSafe stopfoo;

// function to run until stopped
void foo()
{
    while( ! stopfoo.get() )
    {
        // replace with something useful
        this_thread::sleep_for (std::chrono::seconds(1));
        cout << "still working!\n";
    }
    cout << "stopped\n";
}

// function to call a top after 5 seconds
void timer()
{
    this_thread::sleep_for (chrono::seconds( 5 ));
    stopfoo.set();
}

int main()
{
    // initialize stop flag
    stopfoo.unset();

    // start timer in its own thread
    thread t (timer);

    // start worker in main thread
    foo();

    t.join();

    return 0;
}

如果可以在主线程中做所有事情，事情可以大大简化。

#include <iostream>
#include <thread>         // std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds

using namespace std;

void foo()
{
    auto t1 = chrono::steady_clock ::now();

    while( chrono::duration_cast<chrono::seconds>(
                chrono::steady_clock ::now() - t1 ).count() < 5 )
    {
        // replace with something useful
        this_thread::sleep_for (std::chrono::seconds(1));
        cout << "still working!\n";
    }
    cout << "stopped\n";
}

int main()
{
    // start worker in main thread
    foo();

    return 0;
}