Проектирование пула потоков

Вам не нужно уничтожать пул потоков в конце области видимости, в любой операционной системе вы можете выполнять код при выгрузке библиотеки, а в C++ компилятор должен вызывать деструкторы всех статических объектов при выгрузке библиотеки. , вам просто нужно сделать пул потоков одноэлементным.

Вот наивная реализация такого дизайна, работающая демо godbolt

#include <thread>
#include <vector>
#include <queue>
#include <future>
#include <optional>
#include <mutex>
#include <condition_variable>
#include <iostream>
#include <atomic>

class TaskQueue
{
    public:
    void push(std::optional<std::packaged_task<void()>> task)
    {
        {
            std::unique_lock lk{m_mutex};
            m_queue.push(std::move(task));
        }
        m_cv.notify_one();
    }
    std::optional<std::packaged_task<void()>> pop()
    {
        std::optional<std::packaged_task<void()>> task;
        {
            std::unique_lock lk(m_mutex);
            m_cv.wait(lk, [this](){ return !this->m_queue.empty();});
            task = std::move(m_queue.front());
            m_queue.pop();
        }
        return task;
    }
    private:
    std::queue<std::optional<std::packaged_task<void()>>> m_queue;
    std::mutex m_mutex;
    std::condition_variable m_cv;

};

class ThreadPool
{
    public:
    static ThreadPool& Instance()
    {
        static ThreadPool pool(std::thread::hardware_concurrency());
        return pool;
    }
    
    template<typename Func>
    std::future<void> push_task(Func&& f)
    {
        std::packaged_task<void()> task{
            [func = std::move(f)] { func(); }
        };
        auto fut = task.get_future();
        m_queue.push(std::move(task));
        return fut;
    }

    private:
    ThreadPool(int thread_count)
    : m_thread_count{thread_count}
    {
        Initialize();
    }
    void worker_task()
    {
        while (m_running)
        {
            auto task = m_queue.pop();
            if (task)
            {
                (*task)();
            }
            else
            {
                break;
            }
        }
    }
    void Initialize()
    {
        m_running = true;
        for (int i = 0; i < m_thread_count; i++)
        {
            m_workers.push_back(std::thread{[this]{this->worker_task();}});
        }
    }

    ~ThreadPool()
    {
        m_running = false;
        for (int i = 0; i < m_thread_count; i++)
        {
            m_queue.push(std::nullopt);
        }
        for (auto&& worker: m_workers)
        {
            if (worker.joinable())
            {
                worker.join();
            }
        }
    // maybe set an exception on every item left in queue
    }
    TaskQueue m_queue;
    std::vector<std::thread> m_workers;
    std::atomic<bool> m_running = false;
    int m_thread_count;
};

template<typename RndIter, typename Func>
void foreach_par(RndIter begin, RndIter end, Func&& func)
{
    std::vector<std::future<void>> futures;
    futures.reserve(std::distance(begin,end));
    auto&& threadpool = ThreadPool::Instance();
    while (begin != end)
    {
        futures.push_back(threadpool.push_task([begin = begin, &func]{ func(*begin);}));
        begin++;
    }
    for (auto&& future: futures)
    {
        future.get();
    }
}

int main()
{
    std::vector<int> vals{1,2,3,4,5};
    foreach_par(vals.begin(), vals.end(), [](int& value) { value *= 2; });

    for (auto&& value: vals)
    {
        std::cout << value << ' ';
    }
}

Обычно библиотеки выполняют дополнительную оптимизацию, например

• уменьшение выделения кучи
• уменьшение блокировок за счет использования безблокировочных структур
• разбивка задач
• очередь на каждого работника и кража работы

Эта реализация не оптимизирована, но она потокобезопасна и не имеет утечек, но вы все равно можете столкнуться с такими проблемами, как один поток, использующий пул потоков после его уничтожения, а также потоки, которые завершаются без известной причины, необходимо возобновить или добавить таймауты.

Если вы разрабатываете свой собственный пул потоков, я бы рекомендовал вам сделать его не одноэлементным, а вместо этого передавать ссылки на него или использовать для него указатель ресурсов и просто создать его в своем main, чтобы обойти неконтролируемый порядок построения/уничтожения статических объектов. , приведенный выше код может сломаться, если кто-то попытается использовать пул потоков во время создания или уничтожения другого статического объекта, у синглтонов есть масса недостатков.