// CallbackTimer.h

#if !defined(__CallbackTimer_h)
#define __CallbackTimer_h

#include <functional>
#include <thread>
#include <atomic>

class CallbackTimer
{
public:
    CallbackTimer(void);
    ~CallbackTimer(void);

public:
    void startWorkerThread(int timeInterval, std::function<void(void)> callbackFunc);
    void stopWorkerThread(void);

private:
    std::thread m_workerThread;
    std::atomic<bool> m_continueWorkerThread;
};

inline CallbackTimer::CallbackTimer(void):
m_continueWorkerThread(false)
{
}

#endif   // __CallbackTimer_h

// CallbackTimer.cpp

#include <chrono>

#include "CallbackTimer.h"

CallbackTimer::~CallbackTimer(void)
{
    if (m_continueWorkerThread.load(std::memory_order_acquire))
    {
        stopWorkerThread();
    }
}

void CallbackTimer::startWorkerThread(int timeInterval, std::function<void(void)> callbackFunc)
{
    if (m_continueWorkerThread.load(std::memory_order_acquire))
    {
        stopWorkerThread();
    }

    m_continueWorkerThread.store(true, std::memory_order_release);

    m_workerThread = std::thread([this, timeInterval, callbackFunc](void)
    {
        while (m_continueWorkerThread.load(std::memory_order_acquire))
        {
            callbackFunc();
            std::this_thread::sleep_for(std::chrono::milliseconds(timeInterval));
        }
    });
}

void CallbackTimer::stopWorkerThread(void)
{
    m_continueWorkerThread.store(false, std::memory_order_release);
    if (m_workerThread.joinable())
    {
        m_workerThread.join();
    }
}