Синхронизация потоков через condition_variable

#include <thread>
#include <future>
#include <atomic>
/*****************************************************************************/
// Флаг прерывания, локальный у каждого потока,
// что бы не передавать дополнительные параметры
// и избежать "висячих" ссылок
using interrupt_flag = std::shared_ptr<std::atomic<bool>>;
thread_local interrupt_flag this_thread_interrupt_flag = std::make_shared<std::atomic<bool>>();
 
// Исключение прерывания
class interruption_ex {};
 
// Функция проверки прерывания потока
void interruption_point()
{
    if (this_thread_interrupt_flag->load(std::memory_order_relaxed))
        throw interruption_ex{};
}
/*****************************************************************************/
class interruptable_thread
{
    std::thread m_thread;
    interrupt_flag m_flag;
 
public:
 
    template<class F>
    interruptable_thread(F fn)
    {
        std::promise<interrupt_flag> p;
        m_thread = std::thread([&p, fn]()
        {
            try
            {
                // Передаем разделяемое владение флагом потока
                p.set_value(this_thread_interrupt_flag);
                // и запускаем функцию потока
                fn();
            }
            catch (const interruption_ex&)
            {
                // Обрабатываем прерывание, если нужно
            }
        });
        m_flag = p.get_future().get();
    }
 
    ~interruptable_thread()
    {   
        // В деструкторе прерываем поток и ждём завершения
        interrupt();
        if (m_thread.joinable())
            m_thread.join();
    }
 
    void interrupt() noexcept
    {
        if (m_flag)
            m_flag->store(true, std::memory_order_relaxed);
    }
 
    //...
};
/*****************************************************************************/
void ThreadBuf()
{
    try
    {
        for (;;)
        {
            // Точки прерывания расставляем на своё усмотрение.
            // Для возможности прерывания во время ожидания
            // этот код не подойдёт(он немного усложнится, читай книги)
            std::this_thread::sleep_for(std::chrono::milliseconds(200));
            interruption_point();
            //Здесь делаем какую-то работу
        }
    }
    catch (const interruption_ex&)
    {
        // Если нужно, и тут обрабатываем прерывание
        throw;
    }
    catch (...)
    {
        // Остальное нужно обработать
    }
}
/*****************************************************************************/
int main()
{
    interruptable_thread thr(&ThreadBuf);
    // Поток можно прервать вручную(thr.interrupt())
    // или это произойдёт автоматически в деструкторе
    //...
}