Ici, j'explique avec quelques exemples
Parallélisme
Un GPU utilise un traitement parallèle pour traiter le même bloc de code ( noyau AKA ) sur des milliers de threads physiques et logiques. Idéalement, le processus démarre et se termine pour tous les threads en même temps. Un seul cœur de processeur sans hyperthreading ne peut pas effectuer de traitement parallèle.
Remarque: je l'ai dit idéalement, car lorsque vous exécutez un noyau avec une taille de 7M appels sur un matériel avec 6M de threads, il doit exécuter deux fois le même code sur tous les 6M threads en parallèle tout en consommant tous les 6M threads à chaque fois.
- un noyau (un morceau de code) est exécuté sur plusieurs processeurs
- simultanément
- avec une seule séquence d'exécution (un noyau doit faire la même chose dans tous les threads, donc les "branchements" ou "if" sont évités car ils consommeront considérablement les ressources en créant beaucoup de NOP (no-operations) pour synchroniser tous les threads)
- essentiellement augmente la vitesse considérablement
- limite drastiquement ce que vous pouvez faire
- dépend fortement du matériel
Remarque: le parallélisme n'est pas limité au GPU.
Concurrence
Un service web reçoit de nombreuses petites demandes en temps réel et il doit traiter chacune de ces demandes différemment, à tout moment, et indépendamment des autres demandes ou des travaux internes. Pourtant, vous voulez que le service Web soit opérationnel à tout moment sans altérer l'état des données ou la santé du système.
Imaginez simplement un utilisateur mettant à jour un enregistrement et un autre utilisateur supprimant le même enregistrement en même temps.
- de nombreuses tâches sont exécutées
- en temps réel (ou à chaque demande)
- avec différentes séquences d'exécution (contrairement au noyau en traitement parallèle, les tâches simultanées peuvent faire différentes choses, vous devrez probablement les mettre en file d'attente ou les hiérarchiser)
- améliore essentiellement le temps de réponse moyen car la tâche n ° 2 n'a pas à attendre la fin de la tâche n ° 1
- sacrifie essentiellement le temps de calcul car de nombreuses tâches s'exécutent en même temps et les ressources sont limitées
- doit gérer correctement les ressources partagées afin de ne pas se bloquer ou de corrompre les données.
Remarque : ces demandes consomment généralement des ressources essentielles telles que la mémoire, la connexion à la base de données ou la bande passante. Pourtant, vous voulez que le service Web soit réactif à tout moment. L'asynchrone est la clé pour la rendre réactive , pas la concurrence
Asynchrone
Un processus lourd (comme une opération d'E / S) peut facilement bloquer l'interface graphique s'il est exécuté sur le thread GUI. Afin de garantir la réactivité de l'interface utilisateur , un processus lourd peut être exécuté de manière asynchrone. Il est préférable d'exécuter des opérations asynchrones similaires une à la fois . Par exemple, plusieurs opérations liées aux E / S peuvent être beaucoup plus lentes si elles sont exécutées en même temps, il est donc préférable de les mettre en file d' attente pour qu'elles commencent
- une tâche ou un lot de tâches est exécuté sur un autre thread
- une fois
- s'il y a une tâche, alors il n'y a pas de séquence donc vous attendez qu'elle se termine ou vous tirez et oubliez
- s'il s'agit d'un lot de tâches, soit vous déclenchez et oubliez tout en même temps, attendez que tout se termine, ou exécutez chaque tâche pour commencer
- réduit essentiellement les performances en raison des frais généraux
- fournit une réactivité à un autre thread (efficace contre le blocage du thread d'interface utilisateur ou d'autres threads essentiels)
Remarque: une opération asynchrone qui est exécutée simultanément (c'est-à-dire plus d'une fois à la fois) est une opération simultanée.
Remarque: la concurrence et l'asynchrone sont souvent confondues. La concurrence fait référence à différentes parties du système travaillant ensemble sans interférer les unes avec les autres (ces problèmes sont souvent résolus avec des verrous, des sémaphores ou des mutex). L'asynchrone est la façon dont vous atteignez la réactivité (comme le threading).
* Remarque: l' asynchrone et le multithreading sont souvent confondus. Le code asynchrone n'implique pas nécessairement un nouveau thread. cela peut être une opération matérielle ou comme Stephan l' appelle une opération pure, lisez ceci
par exemple, dans le code WPF + C # ci-dessous, await Task.Run(()=> HeavyMethod(txt))résout un problème d'asynchrone, tout en textBox.Dispatcher.Invokerésolvant un problème de concurrence:
private async void ButtonClick(object sender, RoutedEventArgs e)
{
// run a method in another thread
await Task.Run(()=> HeavyMethod(txt));
// modify UI object in UI thread
txt.Text = "done";
}
// This is a thread-safe method. You can run it in any thread
internal void HeavyMethod(TextBox textBox)
{
while (stillWorking)
{
// use Dispatcher to safely invoke UI operations
textBox.Dispatcher.Invoke(() =>
{
// UI operations outside of invoke will cause ThreadException
textBox.Text += ".";
});
}
}
