Maison >développement back-end >Golang >Stratégie de planification de la coroutine Golang
La planification des coroutines Go a trois stratégies : G0 et G1 : planification préemptive, priorité G1 > G0 et G1 : planification préemptive, priorité G1 > Planification non préemptive : la coroutine s'exécute jusqu'à ce qu'elle abandonne activement les droits d'exécution du processeur.
Les coroutines sont des mécanismes de concurrence légers dans Go. La politique de planification détermine la manière dont l'exécution de la coroutine est planifiée. Go propose trois stratégies de planification :
G0 et G1 sont tous deux des planifications préemptives. Cela signifie qu'une coroutine en cours d'exécution peut être préemptée par une coroutine de priorité plus élevée.
G1 a une priorité plus élevée que G0. Si les deux coroutines sont à l’état exécutable, la coroutine G1 sera exécutée en premier.
La planification non préemptive est non préemptive. Cela signifie que les coroutines en cours d’exécution ne peuvent pas être préemptées. Il continuera à fonctionner jusqu'à ce que l'exécution du processeur soit volontairement cédée.
package main import ( "fmt" "runtime" "sync" ) func main() { var wg sync.WaitGroup defer wg.Wait() for i := 0; i < 2; i++ { wg.Add(1) go func(i int) { defer wg.Done() fmt.Printf("协程 %d 在 G0 调度器上执行\n", i) runtime.Gosched() }(i) } }
package main import ( "fmt" "runtime" "sync" ) func main() { runtime.LockOSThread() for i := 0; i < 2; i++ { go func(i int) { fmt.Printf("协程 %d 使用非抢占式调度\n", i) }(i) } }
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!