EventLoopUtils.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
#ifndef TRIGSERVICES_EVENTLOOPUTILS_H
#define TRIGSERVICES_EVENTLOOPUTILS_H
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <functional>
#include <memory>
#include <mutex>
#include <thread>
 
namespace HLT {
  class LoopThread {
  private:
    std::condition_variable m_cond;
    std::mutex m_mutex;
    std::atomic<bool> m_keepRunning{true};
    std::atomic<bool> m_started{false};
    std::atomic<bool> m_finished{false};
    std::function<void()> m_callback;
    int m_callbackIntervalMilliseconds{-1};
    std::unique_ptr<std::thread> m_thread;

    inline void waitForCond(std::unique_lock<std::mutex>& lock) {
      if (m_callbackIntervalMilliseconds < 0) {
        m_cond.wait(lock);
      } else {
        m_cond.wait_for(lock, std::chrono::milliseconds(m_callbackIntervalMilliseconds));
      }
    }

    void run() {
      if (!m_keepRunning) {return;}
      std::unique_lock<std::mutex> lock{m_mutex};
 
      // first call outside the loop to set the m_started flag
      waitForCond(lock);
      m_started = true;
      m_callback();
 
      // subsequent calls in a loop
      while(m_keepRunning) {
        waitForCond(lock);
        m_callback();
      }
      m_finished = true;
    }
 
  public:
    explicit LoopThread(std::function<void()>&& callback, int callbackInterval=-1)
    : m_callback(std::move(callback)),
      m_callbackIntervalMilliseconds(callbackInterval),
      m_thread(std::make_unique<std::thread>([this]{run();})) {}
 
    ~LoopThread() {
      wait();
    }
 
    // Copy and move not allowed
    LoopThread(const LoopThread&) = delete;
    LoopThread(LoopThread&&) = delete;
    LoopThread& operator=(const LoopThread&) = delete;
    LoopThread& operator=(LoopThread&&) = delete;

    void start() {
      while (!m_started) {
        std::this_thread::sleep_for(std::chrono::milliseconds(3));
        m_cond.notify_one();
      }
    }

    void stop() {
      m_keepRunning=false;
      m_cond.notify_all();
    }

    void wait() {
      // Nothing to do if thread already finished
      if (m_thread==nullptr || !m_thread->joinable()) {return;}
      // Keep notifying the condition until the loop finishes
      while (!m_finished) {
        std::this_thread::sleep_for(std::chrono::milliseconds(3));
        m_cond.notify_all();
      }
      // Wait for the thread to return
      m_thread->join();
    }
 
    std::condition_variable& cond() {return m_cond;}
    std::mutex& mutex() {return m_mutex;}
  };
} // namespace HLT
 
#endif // TRIGSERVICES_EVENTLOOPUTILS_H