std::string uuid_v4() {
    uint8_t bytes[16];

    std::random_device rd;
    std::uniform_int_distribution<int> dist(0, 255);
    for (auto &b : bytes)
        b = static_cast<uint8_t>(dist(rd));

    bytes[6] = (bytes[6] & 0x0F) | 0x40; // версия 4
    bytes[8] = (bytes[8] & 0x3F) | 0x80; // вариант RFC 4122

    std::ostringstream oss;
    for (int i = 0; i < 16; ++i) {
        oss << std::hex << std::setw(2) << std::setfill('0') << int(bytes[i]);
        if (i == 3 || i == 5 || i == 7 || i == 9)
            oss << '-';
    }
    return oss.str();
}

Составляю ссылочку: GitHub 📱

class ThreadPool {
    std::queue<std::function<void()>> jobs;  // очередь заданий
    std::mutex              m;
    std::condition_variable cv;
    bool                    stop = false;
    std::vector<std::jthread> workers;       // jthread = RAII-join

public:
    ThreadPool(size_t n = std::thread::hardware_concurrency()) {
        for (size_t i = 0; i < n; ++i)
            workers.emplace_back([this](std::stop_token st) {
                while (!st.stop_requested()) {
                    std::function<void()> job;
                    {   std::unique_lock lk(m);
                        cv.wait(lk, [this]{ return stop || !jobs.empty(); });
                        if (stop && jobs.empty()) return;
                        job = std::move(jobs.front()); jobs.pop();
                    }
                    job();                   // выполняем задачу
                }
            });
    }

    template<typename F>
    void enqueue(F&& f) {
        { std::lock_guard lk(m); jobs.emplace(std::forward<F>(f)); }
        cv.notify_one();                     // будим один поток
    }

    ~ThreadPool() {
        { std::lock_guard lk(m); stop = true; }
        cv.notify_all();                     // будим всех для выхода
    }
};

int main() {
    ThreadPool pool(4);                      // 4 рабочих потока
    for (int i = 0; i < 8; ++i)
        pool.enqueue([i]{ std::printf("job %d\n", i); });
}   // ← при выходе pool завершит все задачи