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

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();

std::vector<std::thread> threads;
for (size_t i = std::thread::hardware_concurrency(); i > 0; --i)
         threads.emplace_back(find_chislo..................

for (auto &thread: threads)
     thread.join();

void  find_chislo(const int *p, size_t n, string &Result_func) {......................
 
..............................
 
const int *p = Chisla.data();
size_t sz = Chisla.size();
for (size_t i = std::thread::hardware_concurrency(); i > 0; --i)
{
    const size_t n = sz / i;
    threads.emplace_back(find_chislo, p, n, std::ref(Result));
    p += n;
    sz -= n;
}

volatile bool stop = false;
 
    for (int i = counter_func*Part; !stop && i < counter_func*Part+Part; i++)
    {
        if (Chisla_func[i] == Find_chislo_func)
        {
stop = true;
            Result_func = to_string(i);
            cout << "нашел" << endl;
 
        }
    }

#include <iostream>
#include <thread>
 
void work()
{
    std::cout << "work...\n";
}
 
int main()
{
    std::thread worker(work);
    worker.join();  // <--- завершился
    
    worker = std::thread(work); // <--- запуск нового потока
    worker.join();
}

#include <iostream>
#include <atomic>
#include <chrono>
#include <thread>
 
std::atomic_bool stop;
 
void work()
{
    while(!stop)
    {
        std::cout << "thread: делаю вид, что работаю...\n";
        std::this_thread::sleep_for(
            std::chrono::seconds(1)
        );
    }
    std::cout << "thread: рабочий день закончился. я пошёль домой\n";
    
}
 
int main()
{
    std::cout << "main: запуск!\n";
    
    std::thread worker(work);
    std::this_thread::sleep_for(
        std::chrono::seconds(3)
    );
    std::cout << "main: сигнал об остановке\n";
    std::cout << "main: ожидаю завершения работы треда\n";
    stop = true;
    worker.join();
    
    std::cout << "main: thread завершился. конец программы\n";
}

std::thread worker(work);
    worker.join();  // <--- завершился
    
worker = std::thread(work); // ТАКИМ образом создается новый поток или ПЕРЕиспользуется уже старый ?
    worker.join();

worker.join();