Comment créer un tableau d'objets thread dans C ++ 11?

Je veux apprendre comment créer plusieurs threads avec la nouvelle norme C++ de la bibliothèque et de stocker leurs poignées dans un tableau.
Comment puis-je commencer un thread?
Les exemples que j'ai vu commencer une discussion avec le constructeur, mais si j'utilise la matrice, je ne peux pas appeler le constructeur.

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

}

source d'informationauteur Squall

  1. 39

    Rien de fantaisie nécessaire; il suffit d'utiliser l'affectation. À l'intérieur de votre boucle, écrire

    myThreads[i] = std::thread(exec, i);

    et cela devrait fonctionner.

  2. -4

    Avec C++0x /C++11, essayez d'utiliser des vecteurs au lieu de tableaux de fils; quelque chose comme ceci:

    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++;
}

    Edit: Si vous voulez vraiment pour gérer l'allocation de la mémoire vous-même et utiliser un tableau de pointeurs (c'est à dire les vecteurs ne sont pas votre truc), alors je ne peux pas le recommander valgrind assez haut. Il a de la mémoire allocation des pions et du fil de dames, etc, etc. Inestimable pour ce genre de chose. En tout cas, voici un exemple de programme utilisant un tableau de manuellement alloué fils, et il nettoie après lui-même (pas de fuites de mémoire):

    #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;
}