Как запустить многопоточность?

void run(std::string threadName) {
    while (true)
    {
        cout <<  threadName  + "\n";
    }
        
}
 
 
 
int main()
{
for(int i = 0;i < 5;i++)
{
 
    std::thread tA(run, to_string(i) + "A");
    tA.join();
}
}

#include <thread>
#include <vector>
#include <iostream>
 
void run(const std::string threadName)
{
    while (true)
    {
        std::cout <<  threadName  << "\n";
    }
}
 
int main()
{
    std::vector<std::thread> list(5);
    int i=0;
    for(auto& t:list)
    {
        t=std::thread(run, std::to_string(i++) + "A");
    }
 
    for(auto& t:list)
    {
        t.join();
    }
}

void run(const std::string& threadName)

size_t i = 0;

int podgotovka(int potok,int k,int k2)
{
 
    cout << " potok "  << potok << k << " k " << k2 << "k2" << endl;
    return 0;
}
int main()
{
std::vector<std::thread> list(5);
    int i = 0;
    int k = 5;
    int k2 = 150 / 5;
    for (auto& t : list)
    {
        t = std::thread(podgotovka, i++ , k , k2);
        k = k2;
        k2 = k2 + k2;
    }
 
    for (auto& t : list)
    {
        t.join();
    }
 
    return 0;
}

#include <sstream>
....
 
 
int podgotovka(int potok,int k,int k2)
{
    std::stringstream ss;
    ss << " potok: "  << potok <<  " k: " << k  << " k2: "<< k2  <<  std::endl;
     std::cout << ss.str();
    return 0;
}

#include <thread>
#include <vector>
#include <iostream>
 
void run(const std::string threadName,int job)
{
    while (true)
    {
        std::cout <<  threadName  << "\n";
    }
}
 
int main()
{
    std::vector<std::thread> list(5);
    int i=0;
for(int job = 0; job < 100; job++)    // знаю что это не так делается :D , эт просто что бы было понятнее....
  {
    for(auto& t:list)
    {
        t=std::thread(run, std::to_string(i++) + "A",job);
    }
 
    for(auto& t:list)
    {
        t.join();
    }
 }
}

// synchronized output to prevent interleaving of results
#define sync_out(m) do{std::ostringstream o; o << m << '\n'; std::cout << o.str();}while(0)
 
void someJob(int id)
{
    sync_out("thread: " << id);
}
 
template<typename Job>
void start_thread(std::vector<std::thread>& threads, Job&& job)
{
    // find an ended thread
    for(auto&& thread: threads)
    {
        if(thread.joinable()) // still running or waiting to join
            continue;
 
        thread = std::thread(job);
        return;
    }
 
    // if not wait for one
    for(auto&& thread: threads)
    {
        if(!thread.joinable()) // dead thread (not run or already joined)
            continue;
 
        thread.join();
        thread = std::thread(job);
        return;
    }
}
 
int main()
{
 
    std::vector<std::thread> threads(5); // 5 threads
 
    for(int i = 0; i < 100; i++)
        start_thread(threads, [=]{someJob(i);});
 
    // wait for any unfinished threads    
    for(auto&& thread: threads)
        if(thread.joinable())
            thread.join();
}