C++ (Qt)
do {
     // эта функция может быть распараллелена
     doHardComputing();
 
    // А это легковесная функция. Она использует результаты, полученные doHardComputing 
    doSomething();
 
} while (condition); // Всё это крутится в цикле пока не сработает условие выхода. 
 

C++ (Qt)
do {
    std::vector<std::thread> threads;
    for (size_t i = 0; i < NThreads; ++i)
        threads.emplace_back(worker); 
 
    for (auto & th : threads)
        th.join();
 
    doSomething();
 
} while(condition);
 

C++ (Qt)
#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <vector>
#include <algorithm>
 
std::mutex mutex;
 
std::condition_variable cv_worker;
std::condition_variable cv_loop;
 
std::atomic_bool is_done(false);
 
static constexpr int NThreads = 8;
 
void worker(std::vector<bool> & flags, unsigned int id)
{
    while (!is_done)
    {
        // Имитация расчётов..
        std::this_thread::sleep_for(std::chrono::seconds(5));
 
        {
            // Каждый worker имеет свой флажёк, который говорит о том, что он выполнил расчёты и готов спать) 
            std::unique_lock<std::mutex> lk(mutex);
            flags[id] = false;
        }
 
        cv_loop.notify_one(); // Пытаемся разбудить потребителя (main_loop)
        // И засыпаем
        std::unique_lock<std::mutex> lk(mutex); 
        cv_worker.wait(lk, [&]()
        {
            return flags[id] || is_done;
        });
    }
}
 
void main_loop(std::vector<bool> & flags)
{
    int i = 0;
    auto cond = [](int i) { return i > 10; }; // условие выхода, для наглядности
 
    do
    {
        {   // Спим до тех пор, пока все workerы не выполнят вычисления (все флажки = false)
            std::unique_lock<std::mutex> lk(mutex);
            cv_loop.wait(lk, [&]()
            {
                return !std::any_of(flags.begin(), flags.end(), [](bool x){ return x; });
            });
        }
 
        // Имитация вычислений..
        std::this_thread::sleep_for(std::chrono::seconds(1));
 
        {   // После вычислений заряжаем флажки
            std::unique_lock<std::mutex> lk(mutex);
            std::fill(flags.begin(), flags.end(), true);
            if (cond(i++))
                is_done = true;
        }
        // Будим всех воркеров и засыпаем 
        cv_worker.notify_all();
 
    } while (!is_done);
}
 
int main()
{
    std::vector<bool> flags(NThreads, false); // флажки
 
    std::thread mainthread(main_loop, std::ref(flags)); // Это наш потребитель
 
    std::vector<std::thread> threads; // Это наши производители workerы
 
    for (unsigned int i = 0; i < NThreads; ++i)
        threads.emplace_back(worker, std::ref(flags), i);
 
    mainthread.join();
 
    for (auto & th : threads)
        th.join();
 
    return 0;
}
 

C++ (Qt)
 std::thread consumer([&]() {
        while (!abortFlag) {
           std::unique_lock<std::mutex> lock(m);
 
/* каждый из worker'ов, закончив работу, уменьшает атомарный счетчик 
workerInProcess и пытается нас (производителя) будить - 
но мы игнорируем побудку если хотя бы один worker активен. 
Собсно идея в этом */ 
            while (workerInProcess) {
                if (abortFlag) return;
                cond_var.wait(lock);
             }
 
/*  В этот момент все worker'ы отстрелялись и висят на (захваченном нами) мутексе, перезаряжаемся */
            if (CheckDone()) break;
            SetupWorkersData();   // заряжаем новые данные worker'ов 
            workerInProcess = NUM_WORKERS;
            cond_var.notify_all();   // стартуем worker'ов, сами засыпаем
        }
 
/* даем worker'ам выйти */
        abortFlag = true;
        cond_var.notify_all();
 
    });

    std::thread worker([&]() {
        while (true) {
 
// Пресекаем "ложные побудки"
          {
            std::unique_lock<std::mutex> lock(m);
            while (!HasData()) {
               if (abortFlag) return;
               cond_var.wait(lock);    // освобождаем мутекс и спим
             } 
          }

// считаем
           DoWorkerJob();
        
// уменьшаем счетчик и будим всех
           --workerInProcess;
           cond_var.notify_all();
    });

void worker(std::vector<bool> & flags, unsigned int id)
{
    while (!is_done)
    {
        // Имитация расчётов..
        std::this_thread::sleep_for(std::chrono::seconds(5));

C++ (Qt)
        {
            // Каждый worker имеет свой флажёк, который говорит о том, что он выполнил расчёты и готов спать) 
            std::unique_lock<std::mutex> lk(mutex);
            flags[id] = false;
        }
 

C++ (Qt)
void worker(bool & flag)
 

C++ (Qt)
bool loop_function() { ... }
 
void do_work() { ... }
 
 
concurrent_loop cloop(num_threads);
 
cloop.start(loop_function, do_work);
 
cloop.join();
 
 

C++ (Qt)
do {
    std::vector<std::thread> threads;
    for (unsigned int i = 0; i < num_threads; ++i)
        threads.emplace_back(do_work);
 
    for (auto & th : threads)
        th.join();
 
} while (loop_function());