线程定时器，中断睡眠（停止它）

Question

我想要一个相当可靠的线程计时器，所以我编写了一个计时器对象，它在线程上触发 std::function。我想让这个计时器能够在它到达下一个刻度之前停止；你不能用 ::sleep 做的事情（至少我不认为你可以）。

所以我所做的就是在互斥体上放置一个条件变量。如果条件超时，我会触发该事件。如果条件发出信号，则线程退出。所以 Stop 方法需要能够让线程停止和/或中断它的等待，我认为这就是它现在正在做的事情。

然而，这存在一些问题。有时线程不是 joinable() ，有时条件是在在超时之后但在进入等待状态之前发出信号。

我怎样才能改进它并使它变得健壮？

以下是完整的回购。此处的等待时间为 10 秒，但程序应在创建 Foo 时立即终止，然后立即销毁。有时会，但大多数情况下不会。

#include <atomic>
#include <thread>
#include <future>
#include <sstream>
#include <chrono>
#include <iostream>

class Timer
{
public:

    Timer() {}

    ~Timer()
    {           
        Stop();
    }

    void Start(std::chrono::milliseconds const & interval, std::function<void(void)> const & callback)
    {   
        Stop();

        thread = std::thread([=]()
        {
            for(;;)
            {
                auto locked = std::unique_lock<std::mutex>(mutex);
                auto result = terminate.wait_for(locked, interval);

                if (result == std::cv_status::timeout)
                {
                    callback();
                }
                else
                {
                    return;
                }
            }
        });
    }

    void Stop()
    {       
        terminate.notify_one();

        if(thread.joinable())
        {
            thread.join();
        }
    }

private:

    std::thread thread;
    std::mutex mutex;
    std::condition_variable terminate;
};

class Foo
{
public: 

    Foo()
    {
        timer = std::make_unique<Timer>();
        timer->Start(std::chrono::milliseconds(10000), std::bind(&Foo::Callback, this));
    }

    ~Foo()
    {

    }

    void Callback()
    {
        static int count = 0;

        std::ostringstream o;

        std::cout << count++ << std::endl;
    }

    std::unique_ptr<Timer> timer;
};


int main(void)
{
    {
        Foo foo;
    }

    return 0;
}

Answer 1

看我的评论。您忘记了实现线程正在等待的事物的状态，从而使互斥体没有任何东西可以保护，线程也没有任何东西可以等待。条件变量是无状态的——你的代码必须跟踪你要通知线程的事物的状态。

这是固定的代码。请注意，互斥锁保护stop，而stop 是线程正在等待的东西。

    class Timer
    {
    public:

        Timer() {}

        ~Timer()
        {           
            Stop();
        }

        void Start(std::chrono::milliseconds const & interval,
            std::function<void(void)> const & callback)
        {   
            Stop();

            {
                auto locked = std::unique_lock<std::mutex>(mutex);    
                stop = false;
            }

            thread = std::thread([=]()
            {
                auto locked = std::unique_lock<std::mutex>(mutex);    

                while (! stop) // We hold the mutex that protects stop
                {
                    auto result = terminate.wait_for(locked, interval);

                    if (result == std::cv_status::timeout)
                    {
                        callback();
                    }
                }
            });
        }

        void Stop()
        {    
            {     
                // Set the predicate
                auto locked = std::unique_lock<std::mutex>(mutex);
                stop = true;
            }

            // Tell the thread the predicate has changed
            terminate.notify_one();

            if(thread.joinable())
            {
                thread.join();
            }
        }

    private:

        bool stop; // This is the thing the thread is waiting for
        std::thread thread;
        std::mutex mutex;
        std::condition_variable terminate;
    };