Les boucles Goroutine continues affament-elles les autres Goroutines en Go ?

Ordonnance coopérative de planification et d'exécution des Goroutines

Les goroutines dans Go sont planifiées de manière coopérative, ce qui signifie qu'elles cèdent explicitement l'exécution à d'autres goroutines plutôt que d'être préemptées par le système d’exploitation. Cela soulève la question : si une goroutine ne cède pas explicitement, empêchera-t-elle d'autres goroutines de s'exécuter ?

Influence des boucles continues

Selon la documentation, les goroutines qui s'exécutent continuellement sans céder peut "affamer" d'autres goroutines sur le même fil. En effet, une goroutine qui exécute perpétuellement une boucle empêche le planificateur d'attribuer des tranches de temps à d'autres goroutines.

Appels de fonction comme points de rendement

Cependant, il est important de noter ces appels de fonction au sein d'une goroutine peuvent agir comme des points d'élasticité implicites. Plus précisément, les appels à des fonctions qui impliquent des ressources système, telles que l'entrée réseau, la mise en veille, les opérations de canal ou le blocage de primitives, déclenchent le planificateur.

Exemple de scénario

Considérez un simple programme Go qui lance quatre goroutines, chacune exécutant une boucle et imprimant une somme :

func sum(x int) {
  sum := 0
  for i := 0; i < x; i++ {
    sum += i
  }
  fmt.Println(sum)
}

Si ces les goroutines sont lancées en même temps que :

go sum(100)
go sum(200)
go sum(300)
go sum(400)

les goroutines ne s'exécuteront pas nécessairement une par une. L'appel fmt.Println() effectué à la fin de chaque goroutine déclenchera le planificateur, permettant à d'autres goroutines de s'exécuter.

Notes supplémentaires

Améliorations récentes du runtime de Go ont introduit des moyens supplémentaires permettant aux goroutines de produire une exécution. Par exemple, il existe une proposition visant à insérer des appels de planificateur dans des boucles sans aucun appel de fonction.

En résumé, même si les boucles continues sans céder peuvent potentiellement affamer d'autres goroutines dans un environnement à thread unique, les appels de fonction et les récentes améliorations d'exécution fournissent mécanismes de planification goroutine même en l'absence de rendement explicite.

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!