Параллельное программирование. Когда несколько потоков зависят от одного и один от нескольких

void base_foo()
{
   for (some_condition)
   {
      some_variable = some_serious_calculation();
      foo(some_variable);
   }
}
 
void foo(some_variable)
{
   for (int i=0; i < big_value; i++)
   {
      some_result[i]= variable;
   }
}

/*
Разделяемые фьючерсы
 
класс std::future позволяет обрабатывать будущий результат
параллельных вычислений. Однако этот результат можно обработать только один раз.
Второй вызов функции get() порождает непредвиденные последствия (в соответствии
с принципами стандартной библиотеки C++ желательно, но не обязательно,
чтобы реализации генерировали исключение std::future_error).
Однако иногда целесообразно несколько раз обрабатывать результат параллельных
вычислений, особенно если его обрабатывают несколько других потоков. Для этой цели
стандартная библиотека C++ предоставляет класс std::shared_future,
который допускает несколько вызовов функции get() и
возвращает один и тот же результат или генерирует одно и то же исключение.
 */
 
#include <future>
#include <thread>
#include <iostream>
#include <exception>
#include <stdexcept>
using namespace std;
 
int queryNumber()
{   
    // считываем число
    cout << "read number: ";
    int num;
    cin >> num;
    
    // генерируем исключение, если ничего не введено
    if (!cin) {
        throw runtime_error("no number read");
    }
 
    return num;
}
 
void doSomething(char c, shared_future<int> f)
{
    try {       
        // получаем количество символов, подлежащих выводу
        int num = f.get();  // get result of queryNumber()
 
        for (int i = 0; i < num; ++i) {
            this_thread::sleep_for(chrono::milliseconds(100));
            cout.put(c).flush();
        }
    }
    catch (const exception& e) {
        cerr << "EXCEPTION in thread " << this_thread::get_id()
            << ": " << e.what() << endl;
    }
}
 
int main()
{
    try {       
        // запускаем поток для запроса числа
        shared_future<int> f = async(queryNumber);
        
        // запускаем три потока, каждый из которых обрабатывает это число в цикле
        auto f1 = async(launch::async, doSomething, '.', f);
        auto f2 = async(launch::async, doSomething, '+', f);
        auto f3 = async(launch::async, doSomething, '*', f);
        
        // ждем завершения всех трех циклов
        f1.get();
        f2.get();
        f3.get();
    }
    catch (const exception& e) {
        cout << "\nEXCEPTION: " << e.what() << endl;
    }
    cout << "\ndone" << endl;
 
    system("pause");
}

for(auto i = 0; i < time; i++)
{
   base_object = some_function();
   for(auto j = 0; j < count_of_objects; j++)
   {
      other_objects[j] = other_function(base_object);
   }
}

std::vector<std::future<other_object>> futs(count_of_objects);
for(auto i = 0; i < time; i++)
{
    base_object = some_function();
    for(auto j = 0; j < count_of_objects; j++)
        futs[j] = std::async(other_function, std::ref(base_object));
 
    for(auto j = 0; j < count_of_objects; j++)
        other_objects[j] = futs[j].wait();
}