Как создать многопоточность

void  find_chislo(vector<int>&Chisla_func, int Find_chislo_func, int chislo_cores_func, string &Result_func, int &counter_func)
{
 
    cout << this_thread::get_id() << " - i:" <<counter_func<< endl;
 
    int Part = Chisla_func.size() / chislo_cores_func;
 
    for (int i = counter_func*Part; i < counter_func*Part+Part; i++)
    {
        if (Chisla_func[i] == Find_chislo_func)
        {
            Result_func = to_string(i);
            cout << "нашел" << endl;
        }
    }
 
}
 
[B]int main()[/B]
{
    setlocale(LC_ALL, "russian");
 
    cout << this_thread::get_id() << " - main" << endl;
 
    int Find_chislo = 6799999;
    int chislo_cores = 3;
    string Result="нет";
 
    int counter;
 
    vector<int>Chisla;
    
    for (int i = 0; i < 10000000; i++)
    {
        Chisla.push_back(i);
    }
 
    counter = 0;
    thread potok1(find_chislo, ref(Chisla), Find_chislo, chislo_cores, ref(Result), ref(counter));
 
    int counter1 = 1;
    thread potok2(find_chislo, ref(Chisla), Find_chislo, chislo_cores, ref(Result), ref(counter1));
 
    int counter2 = 2;
    thread potok3(find_chislo, ref(Chisla), Find_chislo, chislo_cores, ref(Result), ref(counter2));
 
 
    potok1.join();
    potok2.join();
    potok3.join();
    
    cout << Result << endl;

    for (int i = 0; i < chislo_cores; i++)
    {
        counter = i;
 
        thread potok_i(find_chislo, ref(Chisla), Find_chislo, chislo_cores, ref(Result), ref(counter));
    }
 
    potok_all.koin();

int main()
{
        // ---- вот здесь в системе один единственный Main.Thread
        {
            auto f1 = std::async(foo);   //<--- создаётся новый тред. 
            f1.get();   
        }
        //<--- здесь объект фьючи уже не существует.
        // однако тредов по прежнему два.
        // созданный чуть выше тред не прекращает своё существование
}

int main()
{
        auto f1  = std::async(foo);
        auto f2  = std::async(foo);
        auto f3  = std::async(foo);
        auto f4  = std::async(foo);
        auto f5  = std::async(foo);
        auto f6  = std::async(foo);
        auto f7  = std::async(foo);
        auto f8  = std::async(foo);   // <--- у машинки 8мь ядер
        auto f9  = std::async(foo);
        auto f10 = std::async(foo);
 
        f1.get();
        f2.get();
        f3.get();
        f4.get();
        f5.get();
        f6.get();
        f7.get();
        f8.get();
        f9.get();
        f10.get();
}

void foo()
{
cout<<"this_thread::get_id()<<endl;"
}
 
Int main()
{
 
for(int i=0; i<10; i++)
{
async(launch::async, foo)
}
 
}

        std::vector<std::future<void>> res;
        for (int i = 0; i < 10; i++)
            res.emplace_back(async(launch::async, foo));

void Foo()
{
this_thread::sleep_for(chrono::milliseconds(10000)); // Задержка 10 сек
cout<<Создался поток:<<this_thread::get_id()<<endl;
}
 
 
int main()
{
    vector<future<void>>Vector_future;
 
    for (int i=0; i<10;i++)
    {
        Vector_future.emplace_back(async(launch::async, Foo);
    }

void monitoring_thread(int &counter_func)
{
for(;;)
{
cout<<counter_func<<endl;  // сдесь просто выводим на консоль, чтобы и визуально еще можно было бы наблюдать, сколько потоков в работе на данный момент.
}
}
 
void foo(int &counter_func)
{
mutex.lock();
counter_func=counter_func+1;
mutex.unlock();
 
//Код функции...
 
mutex.lock();
counter_func=counter_func-1;
mutex.unlock();
}
 
 
 
int main()
{
int counter=0; 
 
thread mntr_thread(monitoring_thread, ref(counter));
 
 
vector<future<void>>Vector_foo;
for (;;)
        if(counter<100)
{
    {
        Vector_foo.emplace_back(async(launch::async, foo);
    }
}
 
}