Quelle est la différence entre les threads et les coroutines dans Golang

Différence : les données du thread sont stockées dans l'espace mémoire en mode noyau tandis que les données de la coroutine sont stockées dans l'espace mémoire en mode utilisateur fourni par le thread. La planification des tâches des threads est implémentée par le noyau, et la méthode de préemption s'appuie sur divers verrous ; la planification des tâches des coroutines est implémentée par un planificateur spécifique implémenté en mode utilisateur.

L'environnement d'exploitation de ce tutoriel : système Windows 10, GO 1.11.2, ordinateur thinkpad t480.

Coroutine
Coroutine, le nom anglais est Coroutine. Mais en langage Go, le nom anglais de coroutine est : gorutine. Il est souvent utilisé pour le multitâche, c'est-à-dire les tâches simultanées. C'est vrai, c'est le travail multithread.

Bien que dans Go, nous n'ayons pas besoin d'écrire directement du code tel que des threads pour effectuer la concurrence, les coroutines de Go s'appuient sur des threads.

Jetons un coup d’œil à leurs différences.

Introduction de base aux fils de discussion. Veuillez rechercher des articles en ligne ici, car il existe de nombreux excellents articles d'introduction sur les fils de discussion.

Caractéristiques des coroutines
Ici, nous listons d'abord directement les caractéristiques des threads, puis les analysons à partir d'exemples.

• Plusieurs coroutines peuvent être gérées par un ou plusieurs threads, La planification des coroutines s'effectue dans le thread dans lequel elles se trouvent.

• peut être planifié, et la stratégie de planification est définie par le code de la couche application, qui peut être hautement personnalisé.

• Haute efficacité d'exécution.

• prend moins de mémoire.

L'extrait de code ci-dessus 1er et 2ème point

我们来看一个例子：
func TestGorutine(t *testing.T) {
	runtime.GOMAXPROCS(1)  // 指定最大 P 为 1，从而管理协程最多的线程为 1 个
	wg := sync.WaitGroup{} // 控制等待所有协程都执行完再退出程序
	wg.Add(2)
	// 运行一个协程
	go func() {
		fmt.Println(1)
		fmt.Println(2)
		fmt.Println(3)
		wg.Done()
	}()

	// 运行第二个协程
	go func() {
		fmt.Println(65)
		fmt.Println(66)
		// 设置个睡眠，让该协程执行超时而被挂起，引起超时调度
		time.Sleep(time.Second)
		fmt.Println(67)
		wg.Done()
	}()
	wg.Wait()}

s'est exécuté après avoir exécuté les deux coroutines, l'ordre de la sortie observée est échelonné . Cela peut être :

656612367

signifie que lors de l'exécution de la coroutine A, vous pouvez interrompre à tout moment l'exécution de la coroutine B. La coroutine B peut également être interrompue pendant le processus d'exécution de la coroutine. UN.
Il semble que l'exécution de la coroutine A et de la coroutine B soit comme un changement de thread, mais veuillez noter que A et B ici s'exécutent tous les deux dans le même thread . Leur planification n'est pas une commutation de thread, mais une une planification de coroutine pure à l'état d'application.
Concernant le code ci-dessus, pourquoi devez-vous spécifier les deux lignes de code suivantes ?

runtime.GOMAXPROCS(1)time.Sleep(time.Second)

Cela nécessite que vous jetiez un œil aux bases de la planification des coroutines de Go. Veuillez lire mon autre article précédent sur l'analyse de la planification :
Le mécanisme de planification des coroutines de Go

Si ce n'est pas le cas, définissez le runtime.GOMAXPROCS. (1), alors le programme démarrera le nombre correspondant de P en fonction du nombre de cœurs de processeur du système d'exploitation, entraînant le démarrage de plusieurs M, c'est-à-dire des threads. Ensuite, les coroutines de notre programme seront affectées à différents threads. À des fins de démonstration, le nombre est défini sur 1 afin qu'ils soient tous affectés au même thread et stockés dans la file d'attente coroutine du thread, en attente d'exécution ou de planification.

Les 3ème et 4ème points dans les fonctionnalités de la coroutine.
3. Haute efficacité d'exécution.
4. Occupe peu de mémoire.

Parce que la commutation de planification de la coroutine n'est pas une commutation de thread, mais est contrôlée par le programme lui-même, il n'y a pas de surcharge de commutation de thread, et. par rapport au multi-threading, plus il y en a, plus les avantages des coroutines en termes de performances sont évidents. La planification s'effectue en mode application plutôt qu'en mode noyau.

Le coût de la mémoire utilise la mémoire du thread dans lequel il se trouve, ce qui signifie que la mémoire du thread peut être utilisée par plusieurs coroutines.

Deuxièmement, la planification de la coroutine ne nécessite pas de mécanisme de verrouillage multi-thread, car il n'y a qu'un seul thread et il n'y a aucun conflit d'écriture de variables en même temps , donc l'efficacité d'exécution est supérieure à celle du multi-threading. Beaucoup plus élevée.

Comparaison globale des coroutines et des threads

比较的点	线程	协程
数据存储	内核态的内存空间	一般是线程提供的用户态内存空间
切换操作	操作最终在内核层完成，应用层需要调用内核层提供的 syscall 底层函数	应用层使用代码进行简单的现场保存和恢复即可
任务调度	由内核实现，抢占方式，依赖各种锁	由用户态的实现的具体调度器进行。例如 go 协程的调度器
语音支持程度	绝大部分编程语言	部分语言：Lua，Go，Python …
实现规范	按照现代操作系统规范实现	无统一规范。在应用层由开发者实现，高度自定义，比如只支持单线程的线程。不同的调度策略，等等

Apprentissage recommandé : Tutoriel Golang

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!