Как задать скорость обработки операций в потоке std::thread?

std::future<int> ft = async(my_thread);
//Помещаем следующий код в цикл
if(ft.wait_for(std::chrono::milliseconds(1000 / n)) == std::future_status::ready)
    ft = async(my_thread);
else
    //Тут можно обработать как будет отзываться ваша программа если выполнение инструкций превышает допустимый диапазон

class Cores{
    public:
        Cores();
        ~Cores();
        bool Is_Busy();
        void Set_Limit_Of_Core(int );
        int Get_Limit_Of_Core();
        void Execute_Task(CallbackType );
    private:
        std::future<int> ft;
        int Limit_Of_Core; //operations per second.
    };

bool Cores::Is_Busy(){
    if(ft.wait_for(std::chrono::milliseconds(1)) == std::future_status::ready)
        return true;
    else
        return false;
}

if(ft.wait_for(std::chrono::milliseconds(1)) == std::future_status::ready)

std::future<int> ft = async(my_thread);//<-- запускаем процедуру

if(ft.wait_for(std::chrono::seconds(0)) != std::future_status::deferrend) {
    /** Обрабатываем фъючерс */
}

void Cores::Execute_Task(CallbackType our_task){    
    ft = std::async(our_task);
}

Core1.Execute_Task(MyTasks.get_elem());

if ((Core1.Is_Busy() != true) && (MyTasks.Is_empty() != true))
            Core1.Execute_Task(MyTasks.get_elem());

int main(){
    Cores Core1;
    Cores Core2;
    Cores Core3;
    Cores Core4;
    Cores Core5;
 
    Tasks MyTasks;
 
    Core1.Set_Core_Perfomance(5);
    Core2.Set_Core_Perfomance(1);
    Core3.Set_Core_Perfomance(1);
    Core4.Set_Core_Perfomance(1);
    Core5.Set_Core_Perfomance(1);
 
    //making tasks
    for (int i=1;i<=10000;i++){
        int Random_Difficulty=(rand() % 5 +1);
        MyTasks.Set_Difficulty_Of_Task(Random_Difficulty);
        MyTasks.Task_Generator();
    }
 
    //waiting cores become FREE
    while (
        (
        Core1.Is_Busy() &&
        Core2.Is_Busy() &&
        Core3.Is_Busy() &&
        Core4.Is_Busy() &&
        Core5.Is_Busy()
        )
        == true)
    {
    };
 
    //test variable;
    long z = 0;
 
    //executing tasks on cores
    while (MyTasks.Is_empty() != true)
    {
        if ((Core1.Is_Busy() != true) && (MyTasks.Is_empty() != true))
            Core1.Execute_Task(MyTasks.get_elem());
        if ((Core2.Is_Busy() != true) && (MyTasks.Is_empty() != true))
            Core2.Execute_Task(MyTasks.get_elem());
        if ((Core3.Is_Busy() != true) && (MyTasks.Is_empty() != true))
            Core3.Execute_Task(MyTasks.get_elem());
        if ((Core4.Is_Busy() != true) && (MyTasks.Is_empty() != true))
            Core4.Execute_Task(MyTasks.get_elem());
        if ((Core5.Is_Busy() != true) && (MyTasks.Is_empty() != true))
            Core5.Execute_Task(MyTasks.get_elem());
        ++z;
    }
 
 
 
//Simple get elements from Queue.
    /*
 
 
    for (int i=1;i<=10;i++){
        CallbackType myfunc = MyTasks.get_elem();
        myfunc();
    }
    */
    std::cout << "RESULT is: "<< z << std::endl;
    getchar();
    return 0;
}

std::future<int> ft = async(std::launch::async, my_thread);//<-- запускаем процедуру сейчас

bool Cores::Is_Busy(){
    if (ft.wait_for(std::chrono::seconds(60)) == std::future_status::ready){
        std::cout << "FREE" << std::endl;
        return false;
    }
    else{
        std::cout << "BUSY" << std::endl;
        return true;
    }

//executing tasks on cores
    while (MyTasks.Is_empty() != true)
    {
        if ((Core1.Is_Busy() != true) && (MyTasks.Is_empty() != true))
            Core1.Execute_Task(MyTasks.get_elem());
}