Как использовать ограниченное количество потоков?

#include <sstream> 
#include <iostream>
#include <fstream>
 
#include <vector>
#include <mutex>
#include <future>
 
#include <filesystem>
 
namespace fs = std::filesystem;
 
using namespace std;
 
// https://codeyarns.com/2015/04/24/asynchronous-threads-in-c/
class DoWorkClass 
{ 
    private:
        std::vector<string>  _data; 
        std::vector<std::future<string>> fut_vec; 
        int qtyThrs=4;
        std::mutex g_display_mutex;     // for cout...
        
    public: 
    DoWorkClass (std::vector<string>& data):_data(data){};
    ~DoWorkClass (){};
    
    string DoRead(string fName) 
     { 
         // Do some hard computation using fName  
         ifstream f(fName);      
         stringstream s;
         if (f) {
             s << f.rdbuf();    // присваиваем буферу s значение
             f.close();
             g_display_mutex.lock();
             cout << fName << ": " << s.str()<< '\n';   // и выводим в консоль
             g_display_mutex.unlock();
         }
            return ("done fx DoRead " + fName + "\n");
     } 
    
    void DoAsync() 
     {   
         int i=0;
         int ii=0;
         int q=qtyThrs;
         while (true) { 
            g_display_mutex.lock();         
            std::cout << "fx DoAsync getting Start:"  << std::endl;
            g_display_mutex.unlock();
              
             // Create qtyThrs async threads 
             for (int i = ii; i < q; ++i)           
             {    
                if (!_data.empty())
                {   fut_vec.push_back(std::async(std::launch::async, &DoWorkClass::DoRead,  this, string(_data.back())));
                    _data.pop_back();
                }
             }
 
             // Collect results from qtyThrs async threads - BLOCKING .get()
             string result = "";
             if(qtyThrs>fut_vec.size()) q=q-qtyThrs+fut_vec.size(); 
             
             for (int j = ii; j < fut_vec.size(); ++j)           
                    result += (fut_vec[j].get()); 
             
             g_display_mutex.lock();
             std::cout << "fx DoAsync getting Finish: \n" << result << std::endl ; 
             g_display_mutex.unlock();
             
             if (_data.empty()) { break;}
             else {
                 ii+=qtyThrs;
                 q+=qtyThrs;
             }
         }
     } 
};
 
int main(int argc, const char *argv[])
{
    std::vector<string> v; // вектор с адресами файлов
    
    fs::path p = fs::current_path();
    p/="test";  
    cout << p << "\n";
    // https://www.bfilipek.com/2017/08/cpp17-details-filesystem.html#working-with-the-path-object
    for (const auto& entry : fs::directory_iterator(p))
    {
        auto filename = entry.path().filename();    //cout << typeid(filename).name() << endl;
        if (fs::is_directory(entry.status()))
            break;
        else if (fs::is_regular_file(entry.status())) {
            string s{entry.path().filename().u8string()};
            v.emplace_back(s);      //cout << entry << '\n' << filename << endl;
        }
    }   
    
    // тестово вектор с адресами файлов
    //for(int i = 0; i < v.size(); ++i)
    //    cout << v[i] << endl;
 
    // асинхр. действия с файлами
    
    DoWorkClass obj(v);
    obj.DoAsync();
 
    system("pause");
    return 0;
}