C++ 11：定期调用 C++ 函数

Question

我已经组合了一个简单的 C++ 计时器类，该类应该从 SO 上的各种示例中定期调用给定的函数，如下所示：

#include <functional>
#include <chrono>
#include <future>
#include <cstdio>

class CallBackTimer
{
public:
    CallBackTimer()
    :_execute(false)
    {}

    void start(int interval, std::function<void(void)> func)
    {
        _execute = true;
        std::thread([&]()
        {
            while (_execute) {
                func();                   
                std::this_thread::sleep_for(
                std::chrono::milliseconds(interval));
            }
        }).detach();
    }

    void stop()
    {
        _execute = false;
    }

private:
    bool            _execute;
};

现在我想从 C++ 类中调用它，如下L

class Processor()
{
    void init()
    {
         timer.start(25, std::bind(&Processor::process, this));
    }

    void process()
    {
        std::cout << "Called" << std::endl;
    }
};

但是，调用时会出现错误

terminate called after throwing an instance of 'std::bad_function_call'
what():  bad_function_call

Answer 1

代码中的问题是“start”函数中的 lambda 表达式使用

[&]

语法通过引用捕获局部变量。这意味着 lambda 通过引用捕获

interval

和

func

变量，它们都是

start()

函数的局部变量，因此，它们在从该函数返回后消失。但是，从该函数返回后，lambda 在分离的线程中仍然存在。这时您会收到“错误函数调用”异常，因为它尝试通过引用不再存在的对象来调用

func

。

您需要做的是按值捕获局部变量，使用 lambda 上的

[=]

语法，如下所示：

void start(int interval, std::function<void(void)> func)
{
    _execute = true;
    std::thread([=]()
    {
        while (_execute) {
            func();                   
            std::this_thread::sleep_for(
            std::chrono::milliseconds(interval));
        }
    }).detach();
}

当我尝试时，这有效。

或者，您也可以更明确地列出您想要捕获的值（我通常建议将其用于 lambda）：

void start(int interval, std::function<void(void)> func)
{
    _execute = true;
    std::thread([this, interval, func]()
    {
        while (_execute) {
            func();                   
            std::this_thread::sleep_for(
            std::chrono::milliseconds(interval));
        }
    }).detach();
}

编辑

正如其他人指出的那样，使用分离线程并不是一个很好的解决方案，因为您可能很容易忘记停止线程，并且无法检查它是否已经在运行。另外，您可能应该使

_execute

标志原子化，只是为了确保它不会被优化并且读/写是线程安全的。你可以这样做：

class CallBackTimer
{
public:
    CallBackTimer()
    :_execute(false)
    {}

    ~CallBackTimer() {
        if( _execute.load(std::memory_order_acquire) ) {
            stop();
        };
    }

    void stop()
    {
        _execute.store(false, std::memory_order_release);
        if( _thd.joinable() )
            _thd.join();
    }

    void start(int interval, std::function<void(void)> func)
    {
        if( _execute.load(std::memory_order_acquire) ) {
            stop();
        };
        _execute.store(true, std::memory_order_release);
        _thd = std::thread([this, interval, func]()
        {
            while (_execute.load(std::memory_order_acquire)) {
                func();                   
                std::this_thread::sleep_for(
                std::chrono::milliseconds(interval));
            }
        });
    }

    bool is_running() const noexcept {
        return ( _execute.load(std::memory_order_acquire) && 
                 _thd.joinable() );
    }

private:
    std::atomic<bool> _execute;
    std::thread _thd;
};

Answer 2

我认为您没有正确使用分离线程。您应该做的是使线程对象成为 CallBackTimer 类的数据成员，然后执行 _execute = false;接下来是 CallBackTimer 类的析构函数中的 thd.join() 。另外，您的 _execute 标志应该是 volatile 或 std::atomic，以确保您的 while 循环不会被优化为 while(true) 循环。