hello world 10 раз

#include <stdio.h> 
#include <pthread.h> 
void *taskl(void *X) { 
 printf ("Hello, word!\n");
 return NULL; 
} 
 
//++++++++++++++++++++++++++++++++++++++
 
int main(int argc, char *argv[]) { 
 
 void* status; 
 
 pthread_t Thread [10];
 
 for (int i= 0; i< 10; i++) {
  pthread_create(&Thread[i],NULL,taskl,NULL); 
  pthread_join(Thread[i], &status);
 }
 getchar ();
 return (0) ; 
}

Hello, word!
Hello, word!
Hello, wo

#include <functional>
#include <iostream>
#include <thread>
#include <chrono>
#include <string>
 
template<class T, class C1, class C2>
struct Bind
{
    Bind(C1 & ktor, std::function<C2(T)> rest) : _ktor(ktor), _rest(rest)
    {
    }
    
    void runCont(std::function<void(T)> k)
    {
        std::function<C2(T)> rest = _rest;
        std::function<void(T)> lambda = [k, rest](T a)
        {
            return rest(a).runCont(k);
        };
        
        _ktor.runCont(lambda);
    }
    
    C1 _ktor;
    std::function<C2(T)> _rest;
};
 
void asyncApi(std::function<void(std::string)> handler)
{
    std::thread th([handler]()
    {
        std::this_thread::sleep_for(std::chrono::seconds(3));
        handler("Hello world from child thread");
    });
    th.detach();
}
 
struct AsyncApi {
    void runCont(std::function<void(std::string)> k) 
    {
        asyncApi(k);
    }
};
 
struct Loop {
    Loop(std::string s) : _s(s) {}
 
    void runCont(std::function<void(std::string)> k) 
    {
        std::cout << _s << std::endl;
        Bind<std::string, AsyncApi, Loop>(AsyncApi(), [](std::string s)  { return Loop(s); }).runCont(k); 
    }
 
    std::string _s;
};
 
int main()
{
    Loop("Loop: ").runCont([](std::string s)
    {
        std::cout << s << std::endl;
    });
 
    for(int i = 0; i < 7; ++i)
    {
        std::cout << "Hello world from parent thread" << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
        
    return 0;
}