Прерывание по таймеру

sleep(100);

// --- timer.h
//#pragma once
 
#include <functional>
#include <stdint.h>
#include <chrono>
 
namespace tools
{
    struct Timer
    {
        //если функция-будильник вернет true, то таймер перезапустится
        typedef ::std::function<bool()> EventWakeUp;
 
        typedef std::chrono::high_resolution_clock Clock;
 
        typedef uint64_t    MicroSeconds;
        typedef double      Seconds;
 
    public:
       ~Timer();
 
        //укажите :
        // --- время, через которое должен сработать будильник,
        // --- функтор, который должен будет запуститься в момент срабатывания будильника,
        // --- числовой идентификатор таймера (если он вам нужен).
        //Имейте ввиду, если функтор будильника вернет true, то будильник снова перезапустится.  
        Timer( const Seconds      delay, const EventWakeUp& wakeup=EventWakeUp(), const int id=0 );
        Timer( const MicroSeconds delay, const EventWakeUp& wakeup=EventWakeUp(), const int id=0 );
        Timer(const int id=0);
 
        //перезапуск будильника, с возможностью указать другой функутор
        void Restart(const Seconds delay,      const EventWakeUp& wakeup=EventWakeUp() );
        void Restart(const MicroSeconds delay, const EventWakeUp& wakeup=EventWakeUp() );
 
        int GetID()const{ return mId;}
    public:
        //вернет промежуток времени с момента последнего запуска этого же метода
        static MicroSeconds QuantMS();
        static Seconds QuantS();
 
        //спать все время в отдельном потоке, а потом пробудиться и вызвать функцию-будильник
        static void BackGround(const Timer::Seconds delay, const Timer::EventWakeUp& wakeup=EventWakeUp());
 
        //усыпить текущий поток, а потом пробудиться и вызвать функцию-будильник
        static void Sleep(const Timer::Seconds delay, const Timer::EventWakeUp& wakeup=EventWakeUp());
    public:
        //засечь время.
        void Mark();
 
        //через какое время сработает будильник
        MicroSeconds RemainingMS()const;
        Seconds RemainingS()const;
 
        //сколько времени уже прошло с момента запуска будильника
        MicroSeconds ElapsedMS()const;
        Seconds ElapsedS()const;
 
        //Приводит механизм будильника в действие
        //вернет true, если будильник ещё не сработал. 
        //В момент срабатывания запустит функцию-будильник
        bool TickTock();
    private:
        int mId; 
        MicroSeconds        mDelay; 
        EventWakeUp         mEvent;
        Clock::time_point   mMark; 
    };
 
}//namespace tools
 
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//#include <tools/timer.h>
#include <thread>
 
namespace tools
{
 
    namespace{
 
        typedef Timer::EventWakeUp  EventWakeUp;
        typedef Timer::MicroSeconds MicroSeconds;
        typedef Timer::Seconds      Seconds;
        typedef Timer::Clock        Clock;
        
        typedef std::chrono::microseconds MSec;
        typedef std::chrono::seconds      Sec;
 
        template<class T> T DeltaTime(Clock::time_point& last)
        {
            const Clock::time_point now = Clock::now();
            const auto result = std::chrono::duration_cast<T>(now - last);
            last = now;
            return result;
        }
 
        Clock::time_point& Quant()
        {
            static Clock::time_point quant;
            return quant;
        }
 
        void Sleeping(const MicroSeconds pause, const EventWakeUp& wakeup)
        {
            do
            {
                std::this_thread::sleep_for(std::chrono::microseconds(pause) );
 
            }while ( wakeup && wakeup() );
        }
 
    }//namespace
 
    MicroSeconds Timer::QuantMS() { return DeltaTime<MSec>(Quant()).count();         }
    Seconds Timer::QuantS()       { return (Seconds)DeltaTime<Sec>(Quant()).count(); }
 
    Timer::Timer(const int id):mId(id){}
 
    Timer::Timer( const Seconds delay, const EventWakeUp& wakeup, const int id):mId(id)
    {
        Restart(delay,wakeup);
    }
 
    Timer::Timer( const MicroSeconds delay, const EventWakeUp& wakeup, const int id):mId(id)
    {
        Restart(delay,wakeup);
    }
    
    
 
    void Timer::Restart(const Seconds delay, const EventWakeUp& wakeup)
    {
        mDelay = static_cast<MicroSeconds>(delay*1000000);
        mEvent = wakeup;
        Mark();
    }
    void Timer::Restart(const MicroSeconds delay,const EventWakeUp& wakeup)
    {
        mDelay = delay;
        mEvent = wakeup;
        Mark();
    }
 
    Timer::~Timer(){}
 
 
    void Timer::Mark() { mMark = Clock::now(); }
 
    MicroSeconds Timer::ElapsedMS()const
    {
        return std::chrono::duration_cast<MSec>(Clock::now() - mMark).count();
    }
    Seconds Timer::ElapsedS()const
    {
        return static_cast<Seconds>( ElapsedMS()/1000000.0 );
    }
 
    MicroSeconds Timer::RemainingMS()const
    {
        if(mMark == Clock::time_point() || mDelay==0) 
            return 0;
        
        const auto elapsed = ElapsedMS(); 
        return (mDelay<=elapsed)? 0: mDelay-elapsed;
    }
    Seconds Timer::RemainingS()const
    {
        if(mMark == Clock::time_point() || mDelay==0) 
            return 0;
 
        const auto elapsed = ElapsedMS(); 
        return (mDelay<=elapsed)? 0.0: (mDelay-elapsed)/1000000.0;
    }
 
    bool Timer::TickTock()
    {
        if(mMark == Clock::time_point())
            return false;
 
        if(RemainingMS()!=0)
            return true;
 
        if(mEvent && mEvent())
            return Mark(), true;
        else
            mMark=Clock::time_point();
        
        return false;
    }
 
 
//-----------------------------------------------------------
    void Timer::BackGround(const Timer::Seconds delay, const Timer::EventWakeUp& wakeup)
    {
        const MicroSeconds pause = static_cast<MicroSeconds>(delay*1000000);
        auto lambda = [pause, wakeup ](){ Sleeping(pause, wakeup); };
        std::thread(lambda).detach();
    }
 
    void Timer::Sleep(const Timer::Seconds delay, const Timer::EventWakeUp& wakeup)
    {
        const auto pause = static_cast<MicroSeconds>(delay*1000000);
        Sleeping(pause, wakeup);
    }
    
}//namespace tools
 
 
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------
 
#include <iostream>
 
 
bool userFunction()
{
    static size_t count = 5;
    
    std::cout << "wake up!\n";
    --count;
    return count!=0;
}
 
int main()
{
    std::cout << "Hello, world!\n";
    
    size_t v=0;
    
    
    // создаем будильник, указывая через сколько секунд нужно сработать.
    // и функцию, которую нужно запустить при срабатывании
    // если функция вернет true,
    // то будильник автоматически перезапустится.
    const double seconds = 0.1; 
    tools::Timer timer(seconds, userFunction);
 
    // TickTock возвращает true, если будильник ещё не сработал
    while( timer.TickTock() )
    {
        // здесь может быть любой ваш код
        
        //std::cout<<" Remaining: "<< timer.RemainingS() <<" seconds\n";
        //std::cout<<" Elapsed: "  << timer.ElapsedS()   <<" seconds\n";
    }
    std::cout << "finished" <<std::endl;
    
}