programmation en simultanéité

Question

Je continue à entendre parler de la programmation concurrente partout. Pouvez-vous nous éclairer un peu sur ce que c'est et comment les nouvelles normes c ++ facilitent la même chose?

Answer 1

La simultanéité est au sujet de votre code à faire plusieurs choses en même temps. Ceci est généralement fait avec explicite de "fils", mais il y a d'autres possibilités. Par exemple, si vous utilisez des directives OpenMP dans votre code, puis d'un compilateur qui prend en charge OpenMP va automatiquement générer des threads pour vous.

Thread est l'abréviation de "thread d'exécution". Dans un single-threaded programme en C++, le démarrage de l'exécution dans le main(), et procède ensuite de manière séquentielle. Dans un programme multi-threadé, le premier thread commence à principal, mais d'autres threads peut être démarré par l'application qui commencent à un utilisateur de la fonction spécifiée. Ces puis exécuter en même temps, ou en parallèle avec le fil d'origine.

Dans C++0x threads sont lancés à l'aide de l' std::thread classe:

void my_function()
{
    // do stuff
}
std::thread my_thread(my_function); // run my_function in its own thread

Le nouveau C++0x standard prend également en charge:

• les valeurs atomiques et les opérations avec l' std::atomic<> modèle de classe
• mutex pour la protection des données (std::mutex, std::recursive_mutex, etc.)
• verrouillage des classes pour faciliter la gestion de durée de vie de verrou (std::lock_guard<>, std::unique_lock<>)
• std::lock et std::try_lock fonctions pour gérer l'acquisition de verrous multiples en même temps sans risquer de blocage
• les variables de condition à l'aise en attente d'un événement (std::condition_variable, std::condition_variable_any)
• les contrats à terme, des promesses et emballé tâches pour simplifier le transfert de données entre threads, et l'attente pour une valeur pour être prêt. Cela répond à la classique "comment puis-je retourner une valeur à partir d'un fil" question.
• "thread-safe" initialisation de locaux objets statiques
• l' thread_local mot clé de déclarer les données locales de thread

J'ai donné un aperçu plus détaillé de la nouvelle C++0x bibliothèque de threads dans mon article sur devx.com: plus Simple Multithreading dans C++0x

Je vous écris à propos de multithreading et de la concurrence en C++ sur mon blog. Je suis également à l'écriture d'un livre sur le sujet: C++ Simultanéité dans l'Action.

Answer 2

Quand vous dites "comment c++ de nouvelles normes de faciliter" la programmation simultanée, je suppose que vous parlez de la bientôt (?) pour être libéré, C++09 standard.

La nouvelle norme tel qu'il est actuellement dans la forme de projet prend en charge les éléments suivants pour aider à la programmation simultanée:

• types atomiques et les adresses
• une classe thread
• thread_local de stockage (qui vient d'être ajouté dans le projet de norme il y a quelques mois)
• exclusion mutuelle (mutex classes)
• les variables de condition, ce qui est particulièrement agréable pour les Fenêtres, car les variables de condition sont difficiles à mettre en œuvre correctement dans Win32. Cela signifie que, finalement, Microsoft devrait fournir un soutien pour les variables de condition, au moins dans le MSVC++ runtime, de sorte qu'il sera facile d'obtenir de bons variable de condition sémantique sur WIn32.

Answer 3

C ++ CSP2 - Concurrence facile pour C ++

http://www.cs.kent.ac.uk/projects/ofa/c++csp/

Le CSP est basé sur un paradigme concurrente approprié, par opposition aux fils, aux verrous et à toutes les autres choses qui sont abordées après coup.

(Voir Occam-Pi pour un langage de programmation simultané (également basé sur CSP))

Answer 4

Peut-être que cette vidéo pourrait vous aider à faire la lumière :-)
http://channel9.msdn.com/posts/Charles/The-Concurrency-Runtime-Fine-Grained-Parallelism-for-C/

Answer 5

La simultanéité consiste à avoir plusieurs threads d'exécution pour un processus donné. À ce jour, C ++ ne le prend pas directement en charge. Cependant, il existe plusieurs bibliothèques qui lieront une fonction donnée à un nouveau thread d'exécution. Le standard Unix est la bibliothèque pthreads.