Est-il intelligent de remplacer boost::thread et boost::mutex avec c++11 équivalents?

Question

Motivation: pourquoi je suis en train d'étudier, c'est que mon génie gestionnaire de projet pense que boost est une autre dépendance et que c'est horrible parce que "vous en dépendent"(j'ai essayé d'expliquer la qualité de boost, puis a abandonné après un certain temps :( ). Plus petite raison pour laquelle je voudrais faire c'est que je voudrais apprendre le c++11 caractéristiques, parce que les gens vont commencer à écrire du code. Donc:

1. Est-il un mappage 1:1 entre #include<thread> #include<mutex>et boost équivalents?
2. Envisagez-vous une bonne idée de remplacer le boost des trucs avec c++11
   des trucs. Mon utilisation est primitif, mais il y a des exemples quand les mst ne marche pas offrir ce que boost? Ou (blasphème) vice-versa?

P. S. J'utilise GCC donc les en-têtes sont là.

Answer 1

Il y a plusieurs différences entre le coup de pouce.Fil et le C++11 standard de la bibliothèque de threads:

• Boost supporte le fil d'annulation, de C++11 fils ne sont pas
• C++11 prend en charge std::async, mais n'a pas de Boost
• Boost a un boost::shared_mutex pour les multi-lecteur/unique rédacteur de verrouillage, ce qui n'est pas présent dans C++11
• C++11 délais d'attente sont différents pour Stimuler les délais d'attente (bien que cela devrait bientôt changer maintenant augmenter.Le Chrono a été accepté).
• Certains noms sont différents (par exemple, boost::unique_future vs std::future)
• L'argument de passage de la sémantique de l' std::thread différents boost::thread --- Boost utilise boost::bind, ce qui nécessite copiable arguments. std::thread permet de déplacer uniquement les types comme std::unique_ptr à être passés comme arguments. En raison de l'utilisation de boost::bind, la sémantique des espaces réservés comme _1 dans les lier expressions peuvent être différentes.
• Si vous n'avez pas appeler explicitement join() ou detach() puis l' boost::thread destructeur et d'affectation opérateur appelle detach() sur le thread de l'objet détruit/assignés. Avec C++11 std::thread de l'objet, cela se traduira par un appel à l' std::terminate() l'abandon et de la demande.

Afin de clarifier le point sur les déplacer uniquement les paramètres, ce qui suit est valable en C++11, et transfère la propriété de l' int de la temporaire std::unique_ptr pour le paramètre d' f1 lorsque le nouveau thread est démarré. Toutefois, si vous utilisez boost::thread alors ça ne marchera pas, car il utilise boost::bind en interne, et std::unique_ptr ne peut pas être copié. Il y a aussi un bug dans le C++11 thread library fourni avec GCC qui empêche ce travail, car il utilise std::bind dans la mise en œuvre.

void f1(std::unique_ptr<int>);
std::thread t1(f1,std::unique_ptr<int>(new int(42)));

Si vous utilisez le Boost, alors vous pouvez probablement passer à C++11 fils relativement indolore si votre compilateur prend en charge (par exemple, dans les versions récentes de GCC sous linux ont un la plupart du temps-mise en œuvre complète du C++11 bibliothèque de threads disponibles en -std=c++0x mode).

Si votre compilateur ne supporte pas C++11 fils, alors vous pouvez être en mesure d'obtenir un tiers de la mise en œuvre telles que ::Thread, mais c'est encore une dépendance.

Answer 2

std::thread est largement calquée boost::thread, avec quelques différences:

• du coup de pouce non-copiable, d'une poignée de-cartes-pour-un-os-fil, de la sémantique sont conservés. Mais ce fil est mobile pour permettre le retour filetage à partir de l'usine de fonctions et de les placer dans des conteneurs.
• Cette proposition s'ajoute l'annulation de l' boost::thread, ce qui est une complication importante. Ce changement a un impact important non seulement sur le fil, mais le reste du C++ le filetage de la bibliothèque. On croit ce grand changement est justifié en raison de l'avantage.
  • Le fil destructeur doit maintenant appeler annuler avant de détacher pour éviter accidentellement fuite de threads enfants lorsque les parents threads sont annulés.
  • Explicite détacher membre est maintenant nécessaire pour permettre de détacher sans annuler.
• Les concepts de fil de la poignée et fil d'identité ont été séparés en deux classes (ils sont de la même classe en boost::thread). C'est pour faciliter la manipulation et le stockage de fil d'identité.
• La possibilité de créer un id de thread qui est garanti pour comparer égale à aucune autre recrutables fil de discussion a été ajoutée (boost::thread n'ont pas cette). C'est pratique pour le code qui veut savoir si elle est exécutée par le même thread que l'appel précédent (récursive les mutex sont un exemple concret).
• Il existe une "porte de sortie" pour obtenir le thread natif de la poignée de sorte que les clients peuvent manipuler les threads à l'aide de l'OS sous-jacent, si désiré.

C'est à partir de 2007, de sorte que certains points sont plus valide: boost::thread a native_handle fonction maintenant, et, comme les commentateurs le soulignent, std::thread n'ont pas d'annulation plus.

Je ne pouvais pas trouver de différences significatives entre boost::mutex et std::mutex.

Answer 3

Il y a une raison de ne pas migrer vers std::thread.

Si vous utilisez la liaison statique, std::thread devient inutilisable en raison de ces gcc bugs/fonctionnalités:

• http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52590
• http://gcc.gnu.org/bugzilla/show_bug.cgi?id=57740

À savoir, si vous appelez std::thread::detach ou std::thread::join il va conduire à une exception ou d'une collision, alors que boost::thread fonctionne bien dans ces cas.

Answer 4

J'ai essayé d'utiliser shared_ptr contre les mst au lieu de boost et j'ai effectivement trouvé un bug de gcc mise en œuvre de cette classe. Ma demande a été s'écraser en raison de destructeur appelé deux fois (cette classe doit être thread-safe et ne devrait pas générer de tels problèmes). Après avoir déménagé à boost::shared_ptr tous les problèmes ont disparu. Les implémentations actuelles de C++11 ne sont pas encore matures.

Boost a également plus de fonctionnalités. Par exemple d'en-tête dans la version std ne fournit pas sérialiseur à un flux de données (c'est à dire le cout << durée). Boost a beaucoup de bibliothèques que l'utilisation de son propre , etc. équivalents, mais ne coopèrent pas avec les versions std.

Pour résumer si vous avez déjà une demande écrite à l'aide de boost, il est plus sûr de garder votre code tel qu'il est, au lieu de mettre un effort de passer au C++11.