Programmation concurrente c ++? [fermé]

Question

Je ne cesse d’entendre parler de la programmation concurrente partout. Pouvez-vous nous expliquer ce qu’il en est et comment les nouvelles normes c ++ facilitent la même chose?

Answer 1

La simultanéité signifie que votre code fait plusieurs choses en même temps. Cela se fait généralement avec des & "; Threads &";; Explicites, mais il existe d'autres possibilités. Par exemple, si vous utilisez des directives OpenMP dans votre code, un compilateur prenant en charge OpenMP générera automatiquement des threads pour vous.

Sujet est l'abréviation de " thread d'exécution &. Dans un programme C ++ à un seul thread, l'exécution commence à main (), puis se poursuit de manière séquentielle. Dans un programme multi-thread, le premier thread commence au niveau du principal, mais des threads supplémentaires peuvent être démarrés par l'application qui démarre à une fonction spécifiée par l'utilisateur. Celles-ci s'exécutent alors simultanément ou en parallèle avec le thread d'origine.

En C ++ 0x, les threads sont démarrés à l'aide de la std::thread classe:

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

La nouvelle norme C ++ 0x prend également en charge:

• valeurs et opérations atomiques avec le std::atomic<> modèle de classe,
• mutex pour la protection des données (std::mutex, std::recursive_mutex, etc.)
• classes de verrous facilitant la gestion de la durée de vie des verrous (std::lock_guard<>, std::unique_lock<>)
• std::lock et std::try_lock fonctions permettant de gérer l’acquisition simultanée de plusieurs verrous sans risque de blocage
• variables de condition pour faciliter l'attente d'un événement (std::condition_variable, std::condition_variable_any)
• les contrats à terme, les promesses et les tâches empaquetées pour simplifier le transfert de données entre les threads et l'attente d'une valeur prête. Cela répond au classique & "Comment retourner une valeur d’un thread &"; question.
• initialisation thread-safe des objets statiques locaux
• le thread_local mot clé pour déclarer les données locales au thread

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

J'écris sur le multithreading et la concurrence du C ++ en mon blog . J'écris également un livre sur le sujet: La concurrence C ++ en action .

Answer 2

Quand vous dites & "comment c ++ les nouvelles normes facilitent &"; programmation concurrente, je suppose que vous parlez du prochain (?) à être publié standard C ++ 09.

La nouvelle norme, dans sa version actuelle, prend en charge les éléments suivants qui aident à la programmation simultanée:

• types et adresses atomiques
• une classe de thread
• stockage thread_local (qui vient d’être ajouté au projet de norme il y a quelques mois)
• exclusion mutuelle (classes de mutex)
• variables de condition - cela est particulièrement intéressant pour Windows, car les variables de condition sont difficiles à implémenter correctement dans Win32. Cela signifie que, finalement, Microsoft devrait prendre en charge les variables de condition au moins dans le runtime de MSVC ++. Il sera donc facile d'obtenir la sémantique correcte des variables de condition sur WIn32.

Answer 3

Peut-être que cette vidéo pourrait vous aider à faire la lumière :-)
http: //channel9.msdn. com / posts / Charles / Le-Concurrence-Exécution-Parallélisme-Raffiné-pour-C /

Answer 4

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. La norme Unix est la bibliothèque pthreads.

Answer 5

C ++ CSP2 - Concurrence facile pour C ++

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

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

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

Answer 6

Mon point de vue légèrement différent, propre aux futures orientations des paradigmes de programmation:

L'accès simultané consiste à écrire votre programme de telle sorte qu'il puisse effectuer plusieurs opérations à la fois si le matériel le prend en charge. Actuellement, la plupart des langages ont des mécanismes assez lourds et compliqués pour permettre au programmeur de le spécifier (par exemple: threads avec synchronisation manuelle, directives de pré-processeur OpenMP, etc.).

À mesure que le matériel s'améliore, il va s'améliorer horizontalement (davantage de cœurs) plutôt que verticalement (simple cœur plus rapide). Cela signifie que les applications devront disposer de & Quot; concurrence simultanée & Quot; afin de mettre à l'échelle avec " plus rapide " Matériel. Les langues tentent actuellement d’évoluer pour mieux prendre en charge cette réalité et se positionner comme la meilleure langue pour un développement futur.

C ++ 0x ajoute davantage de prise en charge intégrée pour " ancien " méthodes de programmation simultanée. Plusieurs fournisseurs de compilateurs ajoutent & Quot; new & Quot; méthodes abstraites du modèle de thread et permettant de prendre des décisions au moment de l'exécution sur le nombre de threads, etc. (en fonction du matériel de la machine); pour Microsoft en particulier, voir F #, runtime de concurrence, extensions parallèles, etc.

L’espoir que cela aide.

Answer 7

C’est le meilleur article pour comprendre la programmation concurrente: Programmation concurrente

Vous obtiendrez une image complète de la programmation simultanée et de C ++ après l'avoir lue.

En résumé, nous pouvons dire que la programmation concurrente consiste à effectuer plusieurs tâches à la fois. Lorsqu'un programme est bloqué, il peut faire d'autres choses. En règle générale, nous sommes bloqués lorsque nous attendons des connexions réseau et que nous traitons avec des entrées / sorties. Nous pouvons faciliter la programmation simultanée à l’aide de fork() et de bibliothèques de threads.