Quelle est la différence entre les threads et les processus en langage Go

Différence : 1. Le thread est la plus petite unité d'exécution d'un programme, tandis que le processus est la plus petite unité de ressources allouées par le système d'exploitation. 2. Un processus se compose d'un ou plusieurs threads. Les threads sont différentes routes d'exécution du code dans un processus. 3. Le changement de contexte de thread est beaucoup plus rapide que le changement de contexte de processus. 4. La commutation de processus nécessite un maximum de ressources et est très inefficace ; la commutation de threads nécessite des ressources moyennes et a une efficacité moyenne. 5. Le processus a sa propre pile et la pile n'est pas partagée entre les processus ; le thread a sa propre pile et partage le tas.

L'environnement d'exploitation de ce tutoriel : système Windows 7, GO version 1.18, ordinateur Dell G3.

Que sont les threads et les processus ?

Un processus

• est un programme avec certaines fonctions indépendantes Un processus d'exécution dynamique sur un ensemble de données
• est une unité indépendante pour l'allocation des ressources et la planification par le système d'exploitation
• Le transporteur d'exécution d'application

Thread

• Un thread est un processus de contrôle séquentiel unique dans l'exécution d'un programme
• C'est la plus petite unité du flux d'exécution d'un programme
• C'est l'unité de base de la planification et de l'allocation du processeur
• Un processus peut avoir un ou plusieurs threads
• L'espace mémoire du programme est partagé entre chaque thread

Planification des tâches

La plupart des systèmes d'exploitation (Windows, Linux) utilisent la préemption de rotation des tranches de temps pour la planification des tâches. méthode .
La méthode de planification est la suivante :

• Dans un processus, lorsqu'une tâche de thread est exécutée pendant quelques millisecondes, elle sera planifiée par le noyau du système d'exploitation

• Le processeur est interrompu via le compteur matériel, donc que le thread est forcé de faire une pause et que le registre du thread est mis en mémoire

• Déterminez quel thread exécuter ensuite en regardant la liste des threads

• Ensuite, le registre du thread est restauré à partir de la mémoire, et enfin l'exécution du thread reprend pour effectuer la tâche suivante

Cette méthode garantit que chaque thread s'exécute à tour de rôle. Étant donné que l'efficacité d'exécution du processeur est très élevée et que la tranche de temps est très courte, il peut rapidement basculer entre les tâches. , donnant l'impression que plusieurs tâches sont exécutées en même temps , c'est ce que nous appelons la concurrence.

La différence entre les processus et les threads

• Un thread est la plus petite unité d'exécution d'un programme, tandis qu'un processus est la plus petite unité de ressources allouées par le système d'exploitation

• Un processus consiste d'un ou plusieurs threads, les threads sont différentes routes d'exécution de code dans un processus

• Le changement de contexte de thread est beaucoup plus rapide que le changement de contexte de processus

• Le changement de processus nécessite les plus grandes ressources et est très inefficace. et son efficacité est moyenne.

• Le processus a sa propre pile, la pile n'est pas partagée entre les processus et est planifiée par le système d'exploitation
  Les threads ont leur propre pile, un tas partagé et sont également planifiés par le système d'exploitation

Multi-threading et multi-core

Processeur multicœur fait référence à l'intégration de plusieurs cœurs de calcul sur un seul processeur pour améliorer la puissance de calcul. Autrement dit, il existe plusieurs cœurs de traitement pour un véritable calcul parallèle, et chaque cœur de traitement correspond à un thread du noyau.

Fil du noyau

Chaque cœur de traitement correspond à un fil du noyau. Par exemple :

Un processeur monocœur correspond à un thread du noyau
• Un processeur dual-core correspond à deux threads du noyau
• Un processeur quad-core correspond à quatre threads du noyau

Le thread du noyau (KLT ) est directement représenté par les Threads pris en charge par le noyau du système d'exploitation. Le thread est commuté par le noyau. Le noyau planifie le thread en exécutant le planificateur et est responsable du mappage des tâches du thread sur chaque processeur.

Technologie Hyper-threading

Actuellement, les processeurs utilisent la

Technologie Hyper-threading pour simuler un cœur de traitement physique en deux cœurs de traitement logique, c'est-à-dire deux threads du noyau. Ainsi, les ordinateurs que nous voyons sont généralement double cœur, quatre threads ou quatre cœurs, huit threads.
Dans le système d'exploitation, nous voyons que le nombre de processeurs est deux fois supérieur au nombre de processeurs physiques réels. Par exemple, les processeurs double cœur et quatre threads peuvent voir 4 processeurs.

Par exemple, le MBP sur lequel j'écris actuellement l'article est un i7 6 cœurs à 12 threads :

Les programmes n'utilisent généralement pas directement les threads du noyau, mais utilisent une interface de haut niveau de threads du noyau - Léger Process , LWP), que nous appelons souvent

thread.

Coroutines

Les coroutines sont basées sur des threads et sont plus légères que les threads. Un thread peut avoir plusieurs coroutines.

Le but de la coroutine

Dans les applications traditionnelles, un thread est généralement créé pour les requêtes réseau afin de compléter la logique métier. S'il y a plusieurs demandes, plusieurs fils de discussion seront créés.
Si vous rencontrez un comportement d'E/S fastidieux, le thread sera toujours dans un état bloqué. Si de nombreux threads sont dans cet état inactif (en attendant que le thread termine son exécution avant de s'exécuter), cela entraînera une application de ressources incomplète. la capacité de débit du système diminue.

Le comportement d'E/S fastidieux le plus courant est celui de JDBC. Le CPU attendra toujours le retour de l'opération d'E/S de données. À ce stade, le thread n'utilise pas du tout le CPU pour effectuer des opérations. mais il est dans un état inactif. Utiliser trop de threads en même temps entraînera également davantage de surcharge de changement de contexte.

Il existe deux solutions aux problèmes ci-dessus :

• Un seul thread plus un rappel asynchrone
  Par exemple, Node.js, Java's Vert Abandonnez la planification actuelle de la coroutine et exécutez la tâche suivante pour éliminer la surcharge de ContexSwith
• 
  .

Caractéristiques des coroutinesLe changement de thread est planifié par le système d'exploitation et les coroutines sont planifiées par l'utilisateur lui-même, donc le changement de contexte est réduit et l'efficacité est améliorée

La taille de pile par défaut du thread est de 1 Mo , tandis que la coroutine est plus légère, proche de 1K. Par conséquent, plusieurs coroutines peuvent être ouvertes dans la même mémoire
• Étant donné que les coroutines sont sur le même thread, la concurrence peut être évitée. Deuxièmement, l'utilisation de verrous
• convient aux scénarios bloqués et nécessitant beaucoup de concurrence. Mais il n'est pas adapté au multi-threading avec de grandes quantités de calculs

Le principe de la coroutineLe processus de la coroutine :

Lorsque le blocage des E/S se produit, il est programmé par le planificateur de la coroutine

• En cédant le flux de données immédiatement (en abandonnant activement) et en enregistrant les données sur la pile actuelle

• Une fois le blocage terminé, la pile est immédiatement restaurée via le thread et le résultat du blocage est mis sur ce fil pour courir

• court dessus par
logique.

Parce que la suspension de la coroutine est entièrement contrôlée par le programme et se produit dans l'état utilisateur ; tandis que l'état de blocage du thread est commuté par le noyau du système d'exploitation et se produit dans l'état du noyau. Coroutine负责调度的线程称为Fiber，比如Golang里的go关键字其实就是负责开启一个Fiber，让func Par conséquent, la surcharge des coroutines est bien inférieure à celle des threads, et il n'y a pas de surcharge de changement de contexte.

Comparaison des threads et des coroutines

Éléments de comparaisonThreadsCoroutinesRessources occupéesL'unité initiale est 1 Mo, fixe et immuableLa taille initiale est généralement de 2 Ko , peut être augmenté selon les besoinsLa planification appartient àElle est complétée par le noyau du système d'exploitationElle est complétée par l'utilisateurSurcharge de commutationChangement de mode de conception (passage du mode utilisateur au mode noyau ), 16 registres, PC, Refreshing SP et autres registresSeules trois valeurs de registre sont modifiées : PC, SP, DXProblèmes de performancesL'utilisation des ressources est trop élevée, la création et la destruction fréquentes entraîneront de graves problèmes de performancesL'utilisation des ressources est faible et n'entraînera pas de graves problèmes de performancesSynchronisation des donnéesNécessite des mécanismes tels que des verrous pour garantir la cohérence et la visibilité des donnéesNe nécessite pas de mécanisme de verrouillage multithread, il y a donc un seul fil. Il n'y a pas de conflit dans l'écriture des variables en même temps. Les ressources partagées sont contrôlées dans la coroutine sans verrouillage, il vous suffit de déterminer l'état, donc l'efficacité d'exécution est bien supérieure à celle des threads[Recommandations associées : Tutoriel vidéo Go,

Enseignement de la programmation】

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!