Quelle est la différence entre la simultanéité et le parallélisme?
Quelle est la différence entre la simultanéité et le parallélisme?
Les exemples sont appréciés.
La simultanéité est le moment où deux tâches ou plus peuvent démarrer, s'exécuter et se terminer dans des périodes qui se chevauchent. Cela ne signifie pas nécessairement qu'ils fonctionneront tous les deux au même moment. Par exemple, multitâche sur une machine monocœur.
Parallélisme correspond au moment où les tâches littéralement sont exécutées simultanément, par exemple sur un processeur multicœur.
Citant Guide de programmation multithread de Sun :
Concurrence: une condition qui existe lorsqu'au moins deux threads progressent. Une forme plus généralisée de parallélisme pouvant inclure le découpage temporel en tant que forme de parallélisme virtuel.
Parallélisme: condition qui survient lorsqu'au moins deux threads s'exécutent simultanément.
J'aime le discours de Rob Pike: La concurrence n'est pas le parallélisme (c'est mieux!) (diapositives)(conversation)
Rob parle généralement de Go et aborde généralement la question de la concurrence/parallélisme dans une explication visuelle et intuitive! Voici un bref résumé:
Task: Gravons un tas de manuels de langage obsolètes! Un à la fois!
Concurrence: Il y a plusieurs décompositions simultanées de la tâche! Un exemple:
Parallélisme: La configuration précédente est mise en parallèle s'il y a au moins deux gophers travaillant en même temps ou non.
Pour ajouter à ce que d'autres ont dit:
La concurrence est comme avoir un jongleur jongler beaucoup de balles. Quoi qu’il en soit, le jongleur n’attrape/lance qu'une balle par main. Le parallélisme consiste à avoir plusieurs jongleurs jongler des balles simultanément.
Disons que vous avez un programme qui a deux threads. Le programme peut s'exécuter de deux manières:
Concurrency Concurrency + parallelism
(Single-Core CPU) (Multi-Core CPU)
___ ___ ___
|th1| |th1|th2|
| | | |___|
|___|___ | |___
|th2| |___|th2|
___|___| ___|___|
|th1| |th1|
|___|___ | |___
|th2| | |th2|
Dans les deux cas, nous avons une concurrence du simple fait que plusieurs threads sont en cours d'exécution.
Si nous exécutions ce programme sur un ordinateur doté d'un seul cœur de processeur, le système d'exploitation basculerait entre les deux threads, permettant ainsi à un thread de s'exécuter à la fois.
Si nous exécutions ce programme sur un ordinateur doté d'un processeur multicœur, nous pourrions alors exécuter les deux threads dans parallel - côte à côte exactement au même moment.
Concurrency: Si deux problèmes ou plus sont résolus par un seul processeur .
Parallélisme: Si un problème est résolu par plusieurs processeurs.
Je vais essayer d'expliquer avec un exemple intéressant et facile à comprendre. :)
Supposons qu'une organisation organise un tournoi d'échecs dans lequel 10 joueurs ( ayant des compétences égales en matière de jeu ) défient un champion professionnel joueur d'échecs. Et comme les échecs sont une partie 1: 1, les organisateurs doivent organiser 10 parties de manière efficace dans le temps, de manière à pouvoir terminer l’ensemble de l’événement le plus rapidement possible.
Espérons que les scénarios suivants décrivent facilement plusieurs façons de mener ces 10 jeux:
1) SERIAL - Disons que le professionnel joue avec chaque personne une par une, c’est-à-dire qu’il commence et termine le jeu avec une personne, puis commence la partie suivante avec la personne suivante, etc. En d'autres termes, ils ont décidé de mener les jeux de manière séquentielle. Donc, si une partie prend 10 minutes, 10 parties durent 100 minutes. Supposons également que la transition d’une partie à l’autre prend 6 secondes, puis pour 10 parties, elle sera de 54 secondes (environ 1 minute).
donc l'ensemble de l'événement sera à peu près terminé en 101 minutes ( PIRE APPROCHE )
2) CONCURRENT - Disons que le professionnel joue son tour et passe au joueur suivant de sorte que les 10 joueurs jouent simultanément mais que le joueur professionnel ne soit pas avec deux personnes à la fois, il joue son tour et passe au joueur suivant. la personne. Supposons maintenant que le joueur professionnel prenne 6 secondes pour jouer son tour et que le temps de transition d'un joueur professionnel n/b à deux joueurs soit de 6 secondes, de sorte que le temps total de transition pour revenir au premier joueur sera de 1 minute (10x6 secondes). Par conséquent, au moment où il revient à la première personne avec laquelle l'événement a été lancé, 2 minutes sont passées (10xtime_per_turn_by_champion + 10xtransition_time = 2 minutes).
En supposant que tous les joueurs prennent 45 secondes pour terminer leur tour, donc sur la base de 10 minutes par match de l’événement SERIAL le no. de tours avant la fin d'une partie devrait 600/(45 + 6) = 11 tours (environ)
Ainsi, l’ensemble de l’événement se terminera approximativement dans 11xtime_per_turn_by_player _ & _ champion + 11xtransition_time_across_10_players = 11x51 + 11x60sec = 561 + 660 = 1221sec = 20.35 minutes (environ)
VOIR L’AMÉLIORATION de 101 minutes à 20,35 minutes ( MEILLEURE APPROCHE )
3) PARALLEL - Disons que les organisateurs obtiennent des fonds supplémentaires et décident donc d'inviter deux joueurs champions professionnels (les deux à égalité) et divisent l'ensemble des 10 mêmes joueurs (challengers) en deux groupes de 5 chacun et les a assignés à deux champions, à savoir un groupe chacun. Maintenant, l’événement progresse en parallèle dans ces deux sets, c’est-à-dire qu’au moins deux joueurs (un dans chaque groupe) jouent contre les deux joueurs professionnels de leur groupe respectif.
Cependant, au sein du groupe, le joueur professionnel prend un joueur à la fois (c’est-à-dire de manière séquentielle). Ainsi, sans aucun calcul, vous pouvez facilement en déduire que l’ensemble de l’événement se terminera en 101/2 = 50,5 minutes à compléter.
VOIR L’AMÉLIORATION de 101 à 50,5 minutes ( GOOD APPROACH )
4) CONCURRENT + PARALLEL - Dans le scénario ci-dessus, supposons que les deux joueurs champions jouent simultanément (lire le deuxième point) avec les 5 joueurs de leur groupe respectif. Les parties d'un groupe à l'autre se déroulent donc en parallèle, mais à l'intérieur d'un groupe. sont en cours d'exécution simultanément.
Ainsi, les jeux d'un groupe seront à peu près terminés dans 11xtime_per_turn_by_player _ & _ champion + 11xtransition_time_across_5_players = 11x51 + 11x30 = 600 + 330 = 930sec = 15,5 minutes (environ)
Ainsi, l’ensemble de l’événement (impliquant deux groupes de ce type en parallèle) s’achèvera en 15,5 minutes environ.
VOIR L’AMÉLIORATION de 101 à 15,5 minutes ( BEST APPROACH )
REMARQUE: dans le scénario ci-dessus, si vous remplacez 10 joueurs par 10 travaux similaires et deux joueurs professionnels par deux cœurs de processeur, l'ordre suivant restera valable:
SÉRIE> PARALLÈLE> CONCURRENT> CONCURRENT + PARALLEL
(REMARQUE: cet ordre peut changer pour d'autres scénarios, car cet ordre dépend fortement de l'interdépendance des travaux, des besoins en communication, des travaux en noir et blanc et des coûts de transition liés aux travaux en noir et blanc.)
concurence: plusieurs flux d'exécution pouvant potentiellement partager des ressources
Ex: deux threads en compétition pour un port d’E/S.
paralélisme: diviser un problème en plusieurs morceaux similaires.
Ex: analyser un gros fichier en exécutant deux processus sur chaque moitié du fichier.
Exemple simple:
Concurrent est: "Deux files d'attente accédant à un guichet automatique"
Le parallèle est: "Deux files d'attente et deux guichets automatiques"
Ils résolvent différents problèmes. La simultanéité résout le problème du manque de ressources de calcul et de nombreuses tâches. Vous créez donc des threads ou des chemins d’exécution indépendants via le code afin de partager le temps disponible sur la ressource rare. Jusqu'à récemment, la simultanéité dominait la discussion en raison de la disponibilité du processeur.
Le parallélisme résout le problème de trouver suffisamment de tâches et les tâches appropriées (celles qui peuvent être séparées correctement) et de les répartir sur des ressources CPU abondantes. Le parallélisme a toujours existé bien sûr, mais il vient au premier plan parce que les processeurs multicœurs sont tellement bon marché.
Imaginez-vous apprendre un nouveau langage de programmation en visionnant un didacticiel vidéo. Vous devez mettre la vidéo en pause, appliquer ce qui a été dit dans le code puis continuer à regarder. C'est de la concurrence.
Maintenant, vous êtes un programmeur professionnel. Et vous aimez écouter de la musique calme tout en codant. C'est du parallélisme.
Prendre plaisir.
Pensez-y comme aux files d'attente de service où le serveur ne peut servir que le premier travail d'une file d'attente.
1 serveur, 1 file d'attente de travaux (avec 5 travaux) -> pas de simultanéité, pas de parallélisme (un seul travail est en cours de traitement, le travail suivant de la file d'attente doit attendre que le travail traité soit terminé et il n'y a pas d'autre serveur à traiter. le service)
1 serveur, 2 files d'attente différentes ou plus (avec 5 tâches par file d'attente) -> accès simultané (puisque le serveur partage le temps avec toutes les 1ères tâches de la file d'attente, de manière égale ou pondérée), toujours pas de parallélisme car à tout moment, il n'y a qu'un seul travail en cours de révision.
2 serveurs ou plus, une file d'attente -> parallélisme (2 tâches effectuées au même moment) mais pas de concurrence (le serveur ne partage pas le temps, le 3ème travail doit attendre que l'un des serveurs se termine.)
2 serveurs ou plus, 2 files d'attente différentes ou plus -> accès simultané et parallélisme
En d'autres termes, la simultanéité est le partage du temps nécessaire pour terminer un travail. Elle PEUT prendre le même temps pour terminer son travail, mais au moins, elle démarre plus tôt. Ce qui est important, c’est que les travaux peuvent être fractionnés en travaux plus petits, ce qui permet l’entrelacement.
Le parallélisme est réalisé avec juste plus de processeurs, de serveurs, de personnes, etc. qui fonctionnent en parallèle.
N'oubliez pas que, si les ressources sont partagées, le parallélisme pur ne peut pas être atteint, mais c'est ici que l'utilisation simultanée serait la meilleure utilisation pratique, en occupant un autre travail qui n'aurait pas besoin de cette ressource.
Accès simultané => Lorsque plusieurs tâches sont exécutées sur des périodes de temps qui se chevauchent avec des ressources partagées (ce qui maximise potentiellement l'utilisation des ressources).
Parallèle => quand une seule tâche est divisée en plusieurs sous-tâches indépendantes simples pouvant être exécutées simultanément.
L'exécution de la programmation concurrente a 2 types: la programmation concurrente non parallèle et la programmation concurrente parallèle (également appelée parallélisme).
La principale différence est que, pour l’œil humain, les fils dans une concurrence simultanée semblent se dérouler en même temps, mais en réalité, ils ne le font pas. Dans les processus de concurrence simultanés non parallèles, les commutateurs changent rapidement et utilisent à tour de rôle le processeur pour le découpage temporel. En mode parallélisme, plusieurs processeurs sont disponibles. Plusieurs threads peuvent donc être exécutés simultanément sur différents processeurs. 
Référence: Introduction à la simultanéité dans les langages de programmation
Je vais offrir une réponse qui entre en conflit avec certaines des réponses populaires ici. À mon avis, la concurrence est un terme général qui inclut le parallélisme. La simultanéité s'applique à toute situation où des tâches ou des unités de travail distinctes se chevauchent dans le temps. Parallélisme s'applique plus spécifiquement aux situations où différentes unités de travail sont évaluées/exécutées au même moment physique. La raison d'être du parallélisme est l'accélération des logiciels pouvant tirer parti de multiples ressources de calcul physiques. L’autre concept majeur qui s’apparente à la concurrence est l’interactivité. Interactivité s'applique lorsque le chevauchement de tâches est visible du monde extérieur. La raison d'être de l'interactivité est de créer des logiciels adaptés aux entités du monde réel, tels que les utilisateurs, les pairs du réseau, les périphériques matériels, etc.
Le parallélisme et l'interactivité sont une dimension presque entièrement indépendante de la concurrence. Pour un projet particulier, les développeurs peuvent se soucier de l'un, de l'autre ou de l'un ou l'autre. Ils ont tendance à se confondre, notamment parce que l’abomination que sont les fils donne un primitif relativement pratique pour faire les deux.
Un peu plus de détails sur le parallélisme :
Le parallélisme existe à de très petites échelles (par exemple, un parallélisme au niveau instruction dans les processeurs), à une échelle moyenne (par exemple, des processeurs multicœurs) et à grande échelle (par exemple, des clusters de calcul hautes performances). La pression exercée sur les développeurs de logiciels pour qu'ils exposent davantage de parallélisme au niveau des threads s'est accrue ces dernières années, en raison de la croissance des processeurs multicœurs. Le parallélisme est intimement lié à la notion de dépendance. Les dépendances limitent la possibilité d'atteindre le parallélisme; deux tâches ne peuvent pas être exécutées en parallèle si l'une dépend de l'autre (ignorer la spéculation).
Les programmeurs utilisent de nombreux modèles et cadres pour exprimer le parallélisme: pipelines, pools de tâches, opérations d'agrégation sur des structures de données ("tableaux parallèles").
Un peu plus de détails sur l'interactivité :
Le moyen le plus élémentaire et le plus courant d’interactivité consiste à utiliser des événements (c’est-à-dire une boucle d’événement et des gestionnaires/rappels). Pour les tâches simples, les événements sont géniaux. Tenter de réaliser des tâches plus complexes avec des événements aboutit à l'extraction de pile (un enfer de rappel.a.k.a. d'inversion de contrôle). Lorsque vous en avez marre des événements, vous pouvez essayer des choses plus exotiques telles que des générateurs, des coroutines (as./k.a. Async/Await), ou des discussions en coopération.
Pour l'amour des logiciels fiables, veuillez ne pas utiliser de threads si ce que vous recherchez est l'interactivité.
Curmudgeonhness
Je n'aime pas le slogan de Rob Pike: "La concurrence n'est pas un parallélisme, c'est un meilleur" La concurrence n'est ni meilleure ni pire que le parallélisme. La simultanéité inclut une interactivité qui ne peut pas être comparée mieux ou moins bien avec le parallélisme. C'est comme dire "le contrôle est meilleur que les données".
En électronique série et parallèles représentent un type de topologie statique, déterminant le comportement réel du circuit. Lorsqu'il n'y a pas de concurrence, le parallélisme est déterministe.
Afin de décrire les phénomènes dynamiques liés au temps , nous utilisons les termes séquentiels et simultanés . Par exemple, un certain résultat peut être obtenu via une certaine séquence (par exemple, une recette). Lorsque nous parlons avec quelqu'un, nous produisons une séquence de mots. Cependant, en réalité, de nombreux autres processus se produisent au même moment et ainsi, concourent au résultat réel d'une action donnée. Si beaucoup de personnes parlent en même temps, des discussions simultanées peuvent interférer avec notre séquence, mais les résultats de cette interférence ne sont pas connus à l'avance. La simultanéité introduit l'indétermination.
Les caractérisations sérielle/parallèle et séquentielle/concurrente sont orthogonales. Un exemple en est la communication numérique. Dans un adaptateur série , un message numérique est temporairement (c'est-à-dire séquentiellement ) répartis sur la même ligne de communication (par exemple, un fil). Dans un adaptateur parallèle , il est également divisé en lignes de communication parallèles (par exemple, de nombreux fils), puis reconstruit à l'extrémité de réception.
Imaginons un jeu avec 9 enfants. Si nous les disposions comme une chaîne, donnions un message au début et le recevions à la fin, nous aurions une communication en série. Plus de mots composent le message, consistant en une séquence d'unités de communication.
I like ice-cream so much. > X > X > X > X > X > X > X > X > X > ....
Ceci est un processus séquentiel reproduit sur une infrastructure série.
Maintenant, imaginons de diviser les enfants en groupes de 3. Nous divisons la phrase en trois parties, donnons la première à l’enfant de la ligne à notre gauche, la seconde à l’enfant de la ligne médiane, etc.
I like ice-cream so much. > I like > X > X > X > .... > ....
> ice-cream > X > X > X > ....
> so much > X > X > X > ....
Ceci est un processus séquentiel reproduit sur une infrastructure parallèle (encore partiellement sérialisé bien que).
Dans les deux cas, en supposant qu'il existe une communication parfaite entre les enfants, le résultat est déterminé à l'avance.
S'il y a d'autres personnes qui parlent au premier enfant en même temps que vous, alors nous aurons processus simultanés. Nous ne savons pas quel processus sera pris en compte par l'infrastructure, le résultat final est donc non déterminé à l'avance.
Parallélisme est l'exécution simultanée de processus sur un multiple cores per CPU ou un multiple CPUs (on a single motherboard).
La simultanéité est lorsque Parallelism est obtenu sur un single core CPU en utilisant des algorithmes de ordonnancement qui divisent le temps de la CPU (tranche de temps). Les processus sont entrelacés.
Unités:
- 1 ou plusieurs cœurs dans un seul CPU (à peu près tous les processeurs modernes)
- 1 ou plusieurs processeurs sur une carte mère (pensez aux vieux serveurs d'école)
- 1 application correspond à 1 programme (pensez au navigateur Chrome)
- 1 programme peut avoir 1 ou plusieurs processus (pensez que chaque onglet du navigateur Chrome est un processus)
- Un processus peut avoir 1 ou plusieurs threads d'un programme (onglet Chrome lisant une vidéo Youtube en un thread, un autre thread généré pour la section des commentaires, un autre pour les informations de connexion des utilisateurs)
- Ainsi, 1 programme peut avoir 1 ou plusieurs threads d'exécution
- 1 processus est
thread(s)+allocated memory resources by OS(tas, registres, pile, classe Mémoire)
La concurrence est la forme généralisée du parallélisme. Par exemple, un programme parallèle peut aussi être appelé concurrent mais reverse n'est pas vrai.
L'exécution simultanée est possible sur un seul processeur (plusieurs threads, gérés par planificateur ou pool de threads)
L'exécution en parallèle n'est pas possible sur un seul processeur mais sur plusieurs processeurs. (Un processus par processeur)
L'informatique distribuée est également un sujet connexe et peut également être appelée informatique simultanée, mais l'inverse n'est pas vrai, comme le parallélisme.
Pour plus de détails, lisez ce document de recherche Concepts de programmation simultanée
J'ai vraiment aimé cette représentation graphique d'une autre réponse - je pense que cela répond à la question beaucoup mieux que beaucoup des réponses ci-dessus
Parallelism vs Concurrency Lorsque deux threads s'exécutent en parallèle, ils s'exécutent tous les deux en même temps. Par exemple, si nous avons deux threads, A et B, leur exécution parallèle ressemblerait à ceci:
CPU 1: A ------------------------->
CPU 2: B ------------------------->
Lorsque deux threads s'exécutent simultanément, leur exécution se chevauche. Le chevauchement peut se produire de deux manières: soit les threads s'exécutent au même moment (c'est-à-dire en parallèle, comme ci-dessus), soit leurs exécutions sont imbriquées dans le processeur, comme suit:
CPU 1: A -----------> B ----------> A -----------> B -------- ->
Ainsi, pour nos besoins, le parallélisme peut être considéré comme un cas particulier de concurrence
Source: Une autre réponse ici
J'espère que cela pourra aider.
La programmation concurrente concerne les opérations qui semblent se chevaucher et concerne principalement la complexité résultant d'un flux de contrôle non déterministe. Les coûts quantitatifs associés aux programmes concurrents sont généralement à la fois le débit et la latence. Les programmes concurrents sont souvent liés à IO mais pas toujours, par exemple. les éboueurs simultanés sont entièrement sur le processeur. L'exemple pédagogique d'un programme simultané est un robot d'indexation Web. Ce programme initie des demandes de pages Web et accepte les réponses simultanément lorsque les résultats des téléchargements sont disponibles, accumulant ainsi un ensemble de pages déjà visitées. Le flux de contrôle n'est pas déterministe car les réponses ne sont pas nécessairement reçues dans le même ordre à chaque exécution du programme. Cette caractéristique peut rendre très difficile le débogage de programmes concurrents. Certaines applications sont fondamentalement concurrentes, par exemple Les serveurs Web doivent gérer les connexions clientes simultanément. Erlang est peut-être le langage à venir le plus prometteur pour la programmation hautement concurrente.
La programmation parallèle concerne les opérations qui se chevauchent dans l'objectif spécifique d'améliorer le débit. On élimine les difficultés de la programmation concurrente en rendant déterministe le flux de contrôle. Généralement, les programmes génèrent des ensembles de tâches enfants qui s'exécutent en parallèle et la tâche parent ne se poursuit qu'une fois que chaque sous-tâche est terminée. Cela rend les programmes parallèles beaucoup plus faciles à déboguer. La partie difficile de la programmation parallèle est l’optimisation des performances en ce qui concerne des problèmes tels que la granularité et la communication. Ce dernier problème reste d'actualité dans le contexte des multicœurs car le transfert de données d'un cache à un autre représente un coût considérable. La multiplication matricielle dense est un exemple pédagogique de la programmation parallèle et peut être résolue efficacement en utilisant l'algorithme Divide-and-Conquer de Straasen et en attaquant les sous-problèmes en parallèle. Cilk est peut-être le langage le plus prometteur pour la programmation parallèle hautes performances sur des ordinateurs à mémoire partagée (y compris les multicœurs).
Copié de ma réponse: https://stackoverflow.com/a/3982782
"Concurrence" est quand il y a plusieurs choses en cours.
Le "parallélisme" est quand des choses concurrentes progressent en même temps.
Exemples de concurrence sans parallélisme:
- Plusieurs threads sur un seul noyau.
- Plusieurs messages dans une file d'attente de messages Win32.
- Plusieurs
SqlDataReaders sur une connexion MARS . - Plusieurs JavaScript promesses dans un onglet du navigateur.
Notez cependant que la différence entre la simultanéité et le parallélisme est souvent une question de perspective. Les exemples ci-dessus ne sont pas parallèles du point de vue de (effets observables de) l’exécution de votre code. Mais il existe un parallélisme au niveau de l’instruction, même au sein d’un même noyau. Il existe des éléments matériels exécutant des tâches en parallèle avec la CPU, puis interrompant celle-ci à la fin. Le GPU pourrait être en train de dessiner à l’écran pendant que votre procédure de fenêtre ou le gestionnaire d’événements est en cours d’exécution. Le SGBD pourrait être en train de parcourir les B-Trees pour la requête suivante pendant que vous récupérez toujours les résultats de la précédente. Le navigateur peut effectuer la mise en page ou la mise en réseau pendant l'exécution de votre Promise.resolve() Etc...
Alors voilà. Le monde est aussi désordonné que toujours;)
Concurrency peut impliquer des tâches exécutées simultanément ou non (elles peuvent en effet être exécutées dans des processeurs/cœurs séparés, mais elles peuvent également être exécutées par "ticks"). Ce qui est important, c'est que la simultanéité fait toujours référence à qui effectue une partie d'une tâche plus importante. Donc, fondamentalement, cela fait partie de certains calculs. Vous devez être intelligent en ce qui concerne ce que vous pouvez faire simultanément et ce qu'il ne faut pas faire et comment le synchroniser.
Parallélisme signifie que vous ne faites que certaines choses en même temps. Ils n'ont pas besoin de faire partie de la résolution d'un problème. Vos threads peuvent, par exemple, résoudre un seul problème chacun. Bien sûr, la synchronisation s’applique également, mais sous un angle différent.
Parallélisme: Plusieurs threads effectuent des tâches similaires, indépendantes les unes des autres en termes de données et de ressources nécessaires. Par exemple: Google Crawler peut générer des milliers de threads et chaque thread peut effectuer sa tâche indépendamment.
Concurrence: La concurrence est prise en compte lorsque vous avez des données partagées, une ressource partagée entre les threads. Dans un système transactionnel, cela signifie que vous devez synchroniser la section critique du code à l'aide de techniques telles que les verrous, les sémaphores, etc.
La manière la plus simple et la plus élégante de comprendre les deux, à mon avis, est la suivante. La simultanéité permet l’entrelacement des exécutions et peut donc donner le illusion du parallélisme. Cela signifie qu'un système simultané peut exécuter votre vidéo Youtube à côté de votre rédaction d'un document dans Word, par exemple. Le système d'exploitation sous-jacent, étant un système simultané, permet à ces tâches d'entrelacer leur exécution. Comme les ordinateurs exécutent les instructions très rapidement, cela donne l’impression de faire deux choses à la fois.
Le parallélisme est quand de telles choses sont en parallèle. Dans l'exemple ci-dessus, vous constaterez peut-être que le code de traitement vidéo est exécuté sur un seul cœur et que l'application Word s'exécute sur un autre. Notez que cela signifie qu'un programme simultané peut également être en parallèle! La structuration de votre application avec des threads et des processus permet à votre programme d'exploiter le matériel sous-jacent et d'être éventuellement exécuté en parallèle.
Pourquoi ne pas tout être parallèle alors? Une des raisons est que la concurrence est un moyen de structuration et une décision de conception visant à faciliter la séparation des problèmes, alors que le parallélisme est souvent utilisé au nom de la performance. Une autre est que certaines choses ne peuvent fondamentalement pas être réalisées en parallèle. Un exemple de ceci serait d'ajouter deux choses à la fin d'une file d'attente - vous ne pouvez pas les insérer en même temps. Quelque chose doit aller en premier et l’autre derrière, sinon vous vous trompez. Bien que nous puissions entrelacer une telle exécution (et obtenir ainsi une file d'attente simultanée), vous ne pouvez pas la mettre en parallèle.
J'espère que cela t'aides!
L'explication de cette source m'a été utile:
La simultanéité est liée à la manière dont une application gère plusieurs tâches, à savoir travaille sur. Une application peut traiter une tâche à la fois (séquentiellement) ou travailler sur plusieurs tâches en même temps (en même temps).
Le parallélisme, en revanche, est lié à la manière dont une application gère chaque tâche individuelle. Une application peut traiter la tâche en série du début à la fin, ou divisez la tâche en sous-tâches qui peut être complété en parallèle.
Comme vous pouvez le constater, une application peut être concurrente, mais pas parallèle . Cela signifie qu'il traite plus d'une tâche à la fois, mais que les tâches ne sont pas décomposées en sous-tâches.
Une application peut également être parallèle mais non concurrente. Ça signifie l'application ne fonctionne que sur une tâche à la fois, et cette tâche est divisé en sous-tâches qui peuvent être traitées en parallèle.
De plus, une application ne peut être ni concurrente ni parallèle . Cela signifie que cela ne fonctionne que sur une tâche à la fois et que la tâche est jamais décomposé en sous-tâches pour une exécution parallèle.
Enfin, une application peut également être simultanée et parallèle, en qu'il fonctionne à la fois sur plusieurs tâches en même temps et qu'il casse également chaque tâche en sous-tâches pour une exécution parallèle. Cependant, certains de les avantages de la simultanéité et du parallélisme peuvent être perdus en cela scénario, car les processeurs de l'ordinateur sont déjà raisonnablement occupés avec soit la concurrence ou le parallélisme seul. La combinaison peut conduire à seulement un petit gain de performance ou même une perte de performance.
La simultanéité simple signifie que plusieurs tâches sont en cours d'exécution (pas nécessairement en parallèle). Par exemple, supposons que nous ayons 3 tâches à tout moment: plusieurs peuvent être exécutées ou toutes peuvent être exécutées en même temps.
Le parallélisme signifie qu'ils fonctionnent littéralement en parallèle. Donc, dans ce cas, les trois doivent fonctionner en même temps.
Génial, laissez-moi prendre un scénario pour montrer ce que je comprends… supposons qu'il y ait 3 enfants nommés: A, B, C. A et B parlent, C écoutez…. Pour A et B, ils sont parallèles: A: Je suis A . B: Je suis B.
Mais pour C, son cerveau doit prendre le processus simultané pour écouter A et B, c’est peut-être: Je suis Je suis A B.
La notion de "concurrence" de Pike est une décision intentionnelle de conception et de mise en œuvre. Une conception de programme compatible simultanée peut ou non présenter un "parallélisme" comportemental; cela dépend de l'environnement d'exécution.
Vous ne voulez pas que le parallélisme soit présenté par un programme qui n'a pas été conçu pour la concurrence. :-) Mais dans la mesure où il s'agit d'un gain net pour les facteurs pertinents (consommation d'énergie, performances, etc.), vous souhaitez une conception à concurrence maximale afin que le système hôte puisse paralléliser son exécution lorsque possible.
Le langage de programmation de Pike Go illustre cela à l'extrême: ses fonctions sont des threads pouvant fonctionner correctement simultanément, c'est-à-dire que l'appel d'une fonction crée toujours un thread qui s'exécutera en parallèle avec l'appelant si le système en est capable. Une application avec des centaines voire des milliers de threads est parfaitement ordinaire dans son monde. (Je ne suis pas un expert de Go, c'est juste ce que je pense.)
"Concurrent", c'est faire des choses - n'importe quoi - en même temps. Ils pourraient être des choses différentes, ou la même chose. Malgré la réponse acceptée, qui fait défaut, il ne s'agit pas de "paraître en même temps". C'est vraiment au même moment. Vous avez besoin de plusieurs cœurs de processeur, utilisant la mémoire partagée d'un hôte ou la mémoire distribuée sur différents hôtes pour exécuter du code simultané. Voici un exemple de pipeline 3 tâches distinctes exécutées simultanément: les tâches de niveau 2 doivent attendre les unités terminées par les tâches de niveau 1 et les tâches de niveau 3 doivent attendre les unités de travail terminées tâche-niveau-2. Un autre exemple est la concurrence entre un producteur et un consommateur; ou plusieurs producteurs et un seul consommateur; lecteurs et écrivains; et al.
"Parallèle" fait les mêmes choses en même temps. C’est simultané, mais c’est le même comportement qui se produit au même moment, et le plus souvent sur des données différentes. L'algèbre des matrices peut souvent être mise en parallèle, car la même opération est exécutée de manière répétée: par exemple, les sommes des colonnes d'une matrice peuvent toutes être calculées en même temps en utilisant le même comportement (sum) mais sur des colonnes différentes. Il est courant de partitionner (fractionner) les colonnes entre les cœurs de processeur disponibles, de manière à ce que vous ayez à peu près la même quantité de travail (nombre de colonnes) gérée par chaque cœur de processeur. Une autre façon de répartir le travail consiste à créer un sac de tâches dans lequel les travailleurs qui terminent leur travail sont confiés à un responsable qui leur confie le travail et obtient plus de travail de manière dynamique jusqu'à ce que tout soit terminé. L’algorithme de billetterie en est un autre.
Non seulement le code numérique peut être parallélisé. Les fichiers peuvent trop souvent être traités en parallèle. Dans une application de traitement de langage naturel, vous devrez peut-être compter le nombre de jetons contenus dans le document pour chacun des millions de fichiers. Ceci est parallèle, car vous comptez les jetons, ce qui correspond au même comportement, pour chaque fichier.
En d'autres termes, le parallélisme se produit lorsque le même comportement est exécuté simultanément. En même temps signifie simultanément, mais pas nécessairement le même comportement. Parallèle est un type particulier de concurrence où la même chose se produit au même moment.
Les termes, par exemple, incluront des instructions atomiques, des sections critiques, une exclusion mutuelle, une attente en rotation, des sémaphores, des moniteurs, des barrières, la transmission de messages, une réduction de la carte, un battement de coeur, une sonnerie, des algorithmes de création de tickets, des threads, MPI, OpenMP.
Le travail de Gregory Andrews est un excellent manuel: la programmation multithread, parallèle et distribuée.