Многопоточное программирование: как распараллелить цикл?

#include <vector>
#include "MyClass"
#include "f1"
#include "f2"
 
int main()
{
 
std::vector<MyClass> V_1;
std::vector<MyClass> V_2;
std::vector<MyClass> V_3;
std::vector<MyClass> V_4;
 
do
{
/********************************/
/* какая-то инициализация векторов */
/********************************/
 
//Работа с векторами 1 (функция f1 принимает вектор по ссылке 
//и работает с его элементами range-based циклом)
 
f1(V_1);
f1(V_2);
f1(V_3);
f1(V_4);
 
//Работа с векторами 2 (функция f2 принимает вектор по ссылке 
//и работает с его элементами range-based циклом)
 
f2(V_1);
f2(V_2);
f2(V_3);
f2(V_4);
 
}while (/*условие*/)
 
return 0;
}

#include <vector>
#include <thread>
#include "MyClass"
#include "f1"
#include "f2"
 
int main()
{
 
std::vector<MyClass> V_1;
std::vector<MyClass> V_2;
std::vector<MyClass> V_3;
std::vector<MyClass> V_4;
 
do
{
/********************************/
/* какая-то  инициализация векторов */
/********************************/
 
//Работа с векторами 1 (функция f1 принимает вектор по ссылке 
//и работает с его элементами range-based циклом)
 
std::thread t1([&]() { f1(V_1); });
std::thread t2([&]() { f1(V_2); });
std::thread t3([&]() { f1(V_3); });
f1(V_4);
 
t1.join();
t2.join();
t3.join();
 
//Работа с векторами 2 (функция f2 принимает вектор по ссылке 
//и работает с его элементами range-based циклом)
 
std::thread t4([&]() { f2(V_1); });
std::thread t5([&]() { f2(V_2); });
std::thread t6([&]() { f2(V_3); });
f2(V_4);
 
t4.join();
t5.join();
t6.join();
 
}while (/*условие*/)
 
return 0;
}

#include <vector>
#include <mutex>
#include <condition_variable>
#include <thread>
#include "MyClass"
 
class Thread_function
{
public:
    enum thread_flags
    {
        STOP,
        F1,
        F2
    };
 
    void Calc_processing(std::vector<MyClass> &My_Vect_1_procs) noexcept;
 
    std::condition_variable Ready_to_Calculate;
    std::mutex Ready_to_Calculate_mutex;
 
    std::condition_variable Ready_to_Continue;
    std::mutex Ready_to_Continue_mutex;
 
    Thread_function()
    {
        this->flag = STOP;
    }
 
    Thread_function(const Thread_function &Other)
    {
        this->flag = Other.flag;
    }
 
    Thread_function(const Thread_function::thread_flags flag)
    {
        this->flag = flag;
    }
 
    void Set_flag(const Thread_function::thread_flags flag)
    {
        this->flag = flag;
    }
 
        //Типа предикаты
    bool Check_F2()
    {
        return (this->flag == F2);
    }
 
    bool Check_F1()
    {
        return (this->flag == F1);
    }
 
    bool Check_STOP()
    {
        return (this->flag == STOP);
    }
 
private:
    volatile thread_flags flag;
}
 
void Thread_function::Сalc_processing(std::vector<MyClass> &My_Vect_1_procs) noexcept
{
    while (true)
    {
        {
            std::unique_lock<std::mutex> lock(this->Ready_to_Calculate_mutex);
            this->Ready_to_Calculate.wait(lock, [&]() { return this->Check_F1(); });
        }
 
        f1(My_Vect_1_procs);
 
        this->Set_flag(STOP);
        this->Ready_to_Continue.notify_one();
        
        {
            std::unique_lock<std::mutex> Lock(this->Ready_to_Calculate_mutex);
            this->Ready_to_Calculate.wait(Lock, [&]() { return this->Check_F2(); });
        }
 
        f2(My_Vect_1_procs);
 
        this->Set_flag(STOP);
        this->Ready_to_Continue.notify_one();
    }
}
 
int main()
{
       const size_t procs = std::thread::hardware_concurrency(); //Максимально возможное число одновременно
                                              //выполняемых потоков
    std::vector<std::vector<MyClass>> My_Vect_1_procs(procs); //Мои объекты для расчетов
 
        std::vector<Thread_function> Els; //Вектор с объектами типа Thread_function
 
    for (size_t i = 0; i < procs - 1; ++i)
    {
        Els.emplace_back(Thread_function::thread_flags::STOP); //Количество элементов типа Thread_function
    }                                                                                          //совпадает с числом потоков
 
    std::vector<std::thread> threads; //Вектор потоков
    for (size_t i = 0; i < procs - 1; ++i)
    {
        threads.emplace_back([&]() //Открываем потоки, засовывая в них метод класса
        {                                        //Thread_function, который берется у каждого объекта данного класса
                                                          //Захват контекста по ссылке, сама функция Calc_processing принимает вектор по ссылке
                                                          //Причем каждому вызову сообщается свой вектор (один веткор резервный, с ним работает мэйн-поток)
            Els[i].Calc_processing(My_Vect_1_procs[i]);
        });
    }
 
 
        do
        {
                for (size_t i = 0; i < procs - 1; ++i) //Сообщаю каждому потоку начать считать первую функцию
        {
            Els[i].Set_flag(Thread_function::thread_flags::F1);
            Els[i].Ready_to_Calculate.notify_one();
        }
        
                f1(My_Vect_1_procs[procs - 1]);
        
        for (size_t i = 0; i < procs - 1; ++i) //Жду, пока все потоки не отчитаются  о выполнении
        {
            {
                std::unique_lock<std::mutex> Lock(Els[i].Ready_to_Continue_mutex);
                Els[i].Ready_to_Continue.wait(Lock, [&]()
                { return (Els[i].Check_STOP()); });
            }
        }
 
                /******************КАКИЕ ТО ДЕЙСТВИЯ****************/
 
                for (size_t i = 0; i < procs - 1; ++i) //Сообщаю каждому потоку начать считать вторую функцию
        {
            Els[i].Set_flag(Thread_function::thread_flags::F2);
            Els[i].Ready_to_Calculate.notify_one();
        }
        
                f2(My_Vect_1_procs[procs - 1]);
        
        for (size_t i = 0; i < procs - 1; ++i) //Жду, пока все потоки не отчитаются  о выполнении
        {
            {
                std::unique_lock<std::mutex> Lock(Els[i].Ready_to_Continue_mutex);
                Els[i].Ready_to_Continue.wait(Lock, [&]()
                { return (Els[i].Check_STOP()); });
            }
        }
 
                 /******************КАКИЕ ТО ДЕЙСТВИЯ****************/
 
         } while (/*УСЛОВИЕ*/);
 
         return 0;
}

std::lock_guard<std::mutex> Lock(Els[i].Ready_to_Continue_mutex);
            Els[i].Set_flag(Thread_function::thread_flags::F2);
            Els[i].Ready_to_Calculate.notify_one();

#include <vector>
#include <mutex>
#include <condition_variable>
#include <thread>
#include "MyClass"
#include "Mesh"
 
class Thread_function
{
public:
    enum thread_flags
    {
        STOP,
        F1,
        F2
    };
 
    void Calc_processing(std::vector<MyClass> &My_Vect_1_procs, Mesh * mesh, int &Contr_Sum) noexcept;
 
    std::condition_variable Ready_to_Continue;
    std::mutex Ready_to_Continue_mutex;
 
    Thread_function(const int Quantity)
    {
    for (int i = 0; i < Quantity; ++i) 
    {
        this->MyVectors.emplace_back();
    }
    }
 
    std::vector<std::vector<MyClass>> MyVectors; //Data - вектор векторов
 
    volatile bool stop_flag = false;
 
    volatile int threads_in_use = 0;
 
    volatile Thread_function::FLAGS Task_flag = Thread_function::FLAGS::STOP;
 
}
 
void Thread_function::Сalc_processing(std::vector<MyClass> &My_Vect_1_procs, Mesh * mesh, int &Contr_Sum) noexcept
{
    while (true)
    {
    while (true)
    {
        {
            std::unique_lock<std::mutex> lock(this->Ready_to_Continue_mutex);
            if (this->stop_flag)
            {
                return;
            }
            if (this->Task_flag == Thread_function::FLAGS::DISTR)
            {
                ++this->threads_in_use;
                break;
            }
            this->Ready_to_Continue.wait(lock);
        }
    }
 
    f1(My_Vect_1_procs, mesh, Contr_Sum);
 
    {
        std::unique_lock<std::mutex> Lock(this->Ready_to_Continue_mutex);
        --this->threads_in_use;
        if (this->threads_in_use == 0)
        {
            this->Task_flag = Thread_function::FLAGS::STOP;
        }
        this->Ready_to_Continue.notify_all();
    }
        
    while (true)
    {
        {
            std::unique_lock<std::mutex> lock(this->Ready_to_Continue_mutex);
            if (this->stop_flag)
            {
                return;
            }
            if (this->Task_flag == Thread_function::FLAGS::MOOVE)
            {
                    ++this->threads_in_use;
                break;
            }
            this->Ready_to_Continue.wait(lock);
        }
    }
 
    f2(My_Vect_1_procs, mesh, Contr_Sum);
 
    {
        std::unique_lock<std::mutex> Lock(this->Ready_to_Continue_mutex);
        --this->threads_in_use;
        if (this->threads_in_use == 0)
        {
            this->Task_flag = Thread_function::FLAGS::STOP;
        }
        this->Ready_to_Continue.notify_all();
    }
        
    }
}
 
int main()
{
int Size = 10000;
   Mesh *mesh = new Mesh[Size];
   int Contr_Sum = 0;
   const size_t procs = std::thread::hardware_concurrency(); 
   MyClass MyVect(procs);
 
    std::vector<std::thread> Threads; //Вектор потоков
    for (size_t i = 0; i < procs - 1; ++i)
    {
    Threads.emplace_back([&]()
    {
        MyVect.Cals_processing(MyVect.MyVectors[i], mesh, Contr_Sum);
    });
        }
 
   
    do
    {
       {
       std::unique_lock<std::mutex> Lock(Els.Ready_to_Continue_mutex);
           Els.Task_flag = Thread_function::FLAGS::F1;
       Els.Ready_to_Continue.notify_all();
    }
        
        f1(MyVect.MeVectors[procs - 1], mesh, Contr_Sum);
        
        {
       std::unique_lock<std::mutex> Lock(Els.Ready_to_Continue_mutex);
       while (Els.Task_flag != Thread_function::FLAGS::STOP || Els.threads_in_use != 0)
       {
        Els.Ready_to_Continue.wait(Lock);
       }
    }
 
        /******************КАКИЕ ТО ДЕЙСТВИЯ****************/
 
        {
        std::unique_lock<std::mutex> Lock(Els.Ready_to_Continue_mutex);
        Els.Task_flag = Thread_function::FLAGS::F2;
        Els.Ready_to_Continue.notify_all();
    }
        
        f2(MyVect.MyVectors[procs - 1], mesh, Contr_Sum);
        
        {
        std::unique_lock<std::mutex> Lock(Els.Ready_to_Continue_mutex);
        while (Els.Task_flag != Thread_function::FLAGS::STOP || Els.threads_in_use != 0)
        {
        Els.Ready_to_Continue.wait(Lock);
        }
    }
 
       /******************КАКИЕ ТО ДЕЙСТВИЯ****************/
 
        } while (/*УСЛОВИЕ*/);
 
    {
    std::unique_lock<std::mutex> Lock(Els.Ready_to_Continue_mutex);
    Els.stop_flag = true;
    Els.Ready_to_Continue.notify_all();
    }
    
   for (auto &thread : Threads)
   {
    if (thread.joinable())
    {
        thread.join();
    }
   }
   Threads.clear();
 
   return 0;
}

void f1..2(std::vector<MyClass> &V_1..procs, Mesh * mesh, int &Contr_Sum)
{
int Count = 0;
std::mutex m_f;
int p; //Номер ячейки сетки, с которым работаем
   for (auto &i : V_1..procs)
   {
       /***ОПРЕДЕЛЕНИЕ ОБРАЩЕНИЯ К КОНКРЕТНОЙ ЯЧЕЙКЕ МАССИВА mesh***/
       p = /* Number */;//Вычислили номер ячейки сетки
      //Какие-то действия
       {
    std::lock_guard<std::mutex> Lock_f(m_f);
    ++mesh[p].Value;
        ++Contr_Sum;
        ++Count;
       }
   }
}

#pragma once
 
#include <cmath>
#include <fstream>
#include <iostream>
#include <conio.h>
#include <sstream>
#include "Get_Velocity.h"
#include "Global_Variables.h"
//#include "Emission_data.h"
 
#define debug_mesh
 
class Spher_1D_Area //Описывает точку сферической области
{
    friend class Spher_Electron;
    friend class Thread_function;
public:
    //static long int Count; //Число точек
    static int Count_max; //Максимальное число точек
    static double Rin; //Радиус внутренней сферы
    static double Rout; //Радиус внешней сферы
    static double h1; //Первый пространственный шаг
    static double k; //Множитель для геометрической прогрессии
    static double Degr_value;
 
    static double Pulse_Duration; //Длительность импульса высокого напряжения
    static double Pulse_Front; //Длительность фронта напряжения
 
    static int Els_count(Spher_1D_Area *Mesh);
 
    Spher_1D_Area(); //Конструктор по умолчанию
    ~Spher_1D_Area(); //Деструктор
 
    static double W_rel;
 
    //Получить индекс точки
    //long int GetID();
 
    //Получить номер ячейки
    static int GetNum(double R);
 
    //Ввести условия моделирования
    friend void Input_Spher_Mesh_Params(Spher_1D_Area buf);
    friend void Input_Spher_Dirihle_Board_Conds(double& left_dir_board_phi, double& right_dir_board_phi, Spher_1D_Area buf);
    //Решить уравнение Пуассона
    friend void Spher_1D_Dirihle_Poisson_Progon(Spher_1D_Area * Mesh);
 
    //Заполнить сетку значениями координат и сеточных коэффициентов
    static void Build_Dirihle_Spher_1D_Mesh(Spher_1D_Area * Mesh);
 
    //Установить ГУ
    static void Set_Dirihle_Board_Conditions(Spher_1D_Area * Mesh, double left, double right, double cur_time);
 
    //Установить множитель для шага сетки, который увеличивается в геометрической прогрессии
    static void SetK();
    
    //Получить катодный потенциал
    static double GetCathodePotential(Spher_1D_Area* Mesh);
 
    //Получить напряженность поля у катода
    static double GetCathodeE_intensity(Spher_1D_Area* Mesh);
 
    //Объем шарового слоя
    static double Spher_Layer_Volume(double Rmax, double Rmin);
 
    //Обнулить заряд на сетке для того, чтобы раздать его заново
    static void ResetChargeDensity(Spher_1D_Area* Mesh);
 
    //Autosave
    static void AutoSave(Spher_1D_Area* Mesh, double TotalTime, double Jo, double Jo_prev);
 
    //Раздача заряда и интерполяция силы
    static double S_func(Spher_1D_Area* Mesh, int p, double ri, double rp);
 
    //Раздача заряда в стационарном приближении сплошной среды
    static void ContinMediumChargeDistr(Spher_1D_Area* Mesh, double J);
 
protected:
    volatile int Quantity;
    //Координата точки
    double Ri;
 
    //Шаг ПОСЛЕ ТОЧКИ
    //double hi;
 
    //Сеточные коэффициенты
    double a;
    double b;
    double c;
 
    //Значение потенциала в данной точке
    double Phi;
 
    //Напряженность поля в точке
    double Ei;
 
    //Значение заряда в данной точке пространства
    double Ro_prev;
    double Ro; /*ВОТ СЮДА МНЕ И НАДО ЗАПИСАТЬ РЕЗУЛЬТАТ РАСЧЕТА ФУНКЦИИ  f1*/
    double DRo;
 
    //Объем ячейки
    double Vp;
 
    //Шаг ячейки (приведенный)
    double hi_Degr;
 
    //long int ID;
 
    //Установить шаг после точки
    //void Set_hi(Spher_1D_Area& Point);
 
    //Коэффициенты для метода прогонки
    double Alpha_prog; 
    double Beta_prog;
 
    static double Get_F_from_k(double K_contr);
    static void E_calculation(Spher_1D_Area * Mesh);
};