Jak utworzyć tablicę obiektów wątków w C++ 11?

Question

Chcę nauczyć się tworzyć wiele wątków za pomocą nowej standardowej biblioteki C++ i przechowywać ich uchwyty w tablicy.
Jak mogę uruchomić wątek?
Przykłady, które widziałem, uruchamiają wątek z konstruktorem, ale jeśli używam tablicy, nie mogę wywołać konstruktora.

#include <iostream> 
#include <thread> 

void exec(int n){ 
    std::cout << "thread " << n << std::endl; 
} 

int main(int argc, char* argv[]){ 

    std::thread myThreads[4]; 

    for (int i=0; i<4; i++){ 
     //myThreads[i].start(exec, i); //?? create, start, run 
     //new (&myThreads[i]) std::thread(exec, i); //I tried it and it seems to work, but it looks like a bad design or an anti-pattern. 
    } 
    for (int i=0; i<4; i++){ 
     myThreads[i].join(); 
    } 

} 

Answer 1

Nic nadzwyczajnego wymagane; po prostu użyj zadania. Wewnątrz pętli napisz:

i powinno działać.

Answer 2

Przy C++ 0x/C++ 11, spróbuj użyć wektorów zamiast tablic wątków; coś takiego:

vector<thread> mythreads; 
int i = 0; 
for (i = 0; i < 8; i++) 
{ 
    mythreads.push_back(dostuff, withstuff); 
} 
auto originalthread = mythreads.begin(); 
//Do other stuff here. 
while (originalthread != mythreads.end()) 
{ 
    originalthread->join(); 
    originalthread++; 
} 

Edycja: Jeśli naprawdę chcesz do obsługi alokacji pamięci siebie i wykorzystywać tablicę wskaźników (czyli wektory prostu nie są twoje rzeczy), to nie mogę polecić valgrind bardzo mało. Ma kontrolery alokacji pamięci i kontrolery wątków, itp., Itp. Bezcenne dla tego rodzaju rzeczy. W każdym razie, oto przykładowy program przy użyciu tablicy ręcznie przydzielone wątków, i sprząta po sobie (nie ma wycieków pamięci):

#include <iostream> 
#include <thread> 
#include <mutex> 
#include <cstdlib> 

// globals are bad, ok? 
std::mutex mymutex; 


int pfunc() 
{ 
    int * i = new int; 
    *i = std::rand() % 10 + 1; 

    // cout is a stream and threads will jumble together as they actually can 
    // all output at the same time. So we'll just lock to access a shared 
    // resource. 
    std::thread::id * myid = new std::thread::id; 
    *myid = std::this_thread::get_id(); 
    mymutex.lock(); 
    std::cout << "Hi.\n"; 
    std::cout << "I'm threadID " << *myid << std::endl; 
    std::cout << "i is " << *i << ".\n"; 
    std::cout << "Bye now.\n"; 
    mymutex.unlock(); 

    // Now we'll sleep in the thread, then return. 
    sleep(*i); 
    // clean up after ourselves. 
    delete i; 
    delete myid; 
    return(0); 
} 


int main() 
{ 

    std::thread * threadpointer = new std::thread[4]; 
    // This seed will give us 5, 6, 4, and 8 second sleeps... 
    std::srand(11); 
    for (int i = 0; i < 4; i++) 
    { 
     threadpointer[i] = std::thread(pfunc); 
    } 
    for (int i = 0; i < 4; i++) 
     // Join will block our main thread, and so the program won't exit until 
     // everyone comes home. 
    { 
     threadpointer[i].join(); 
    } 
    delete [] threadpointer; 
}