thread_manager.hpp

Go to the documentation of this file.

#pragma once
 
#include "threading/jthread_compat.hpp"
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <mutex>
#include <string>
#include <vector>
 
namespace libstp::threading
{
    using DaemonFn = std::function<void(stop_token)>;

    class ThreadManager
    {
    public:
        class DaemonHandle;
 
        static ThreadManager& instance();

        [[nodiscard]] DaemonHandle add_daemon(std::string name, DaemonFn fn);

        void add_persistent_daemon(std::string name, DaemonFn fn);

        void shutdown();

        [[nodiscard]] std::size_t daemon_count() const;
 
        ~ThreadManager();
        ThreadManager(const ThreadManager&) = delete;
        ThreadManager& operator=(const ThreadManager&) = delete;
 
    private:
        friend class DaemonHandle;
 
        ThreadManager() = default;

        void stop_by_id(std::uint64_t id) noexcept;
 
        struct Daemon
        {
            std::uint64_t id;     
            std::string   name;
            jthread       thread;
        };
 
        mutable std::mutex  mu_;
        std::vector<Daemon> daemons_;
        std::uint64_t       next_id_  = 1;
        bool                shutdown_ = false;
    };

    class ThreadManager::DaemonHandle
    {
    public:
        DaemonHandle() noexcept = default;
        ~DaemonHandle() { stop(); }
 
        DaemonHandle(const DaemonHandle&)            = delete;
        DaemonHandle& operator=(const DaemonHandle&) = delete;
 
        DaemonHandle(DaemonHandle&& other) noexcept
            : mgr_(other.mgr_), id_(other.id_)
        {
            other.mgr_ = nullptr;
            other.id_  = 0;
        }
 
        DaemonHandle& operator=(DaemonHandle&& other) noexcept
        {
            if (this != &other)
            {
                stop();
                mgr_       = other.mgr_;
                id_        = other.id_;
                other.mgr_ = nullptr;
                other.id_  = 0;
            }
            return *this;
        }

        void stop() noexcept
        {
            if (mgr_ != nullptr && id_ != 0)
            {
                mgr_->stop_by_id(id_);
            }
            mgr_ = nullptr;
            id_  = 0;
        }
 
        [[nodiscard]] bool owns_thread() const noexcept { return mgr_ != nullptr && id_ != 0; }
 
    private:
        friend class ThreadManager;
        DaemonHandle(ThreadManager* mgr, std::uint64_t id) noexcept
            : mgr_(mgr), id_(id)
        {
        }
 
        ThreadManager* mgr_ = nullptr;
        std::uint64_t  id_  = 0;
    };
}