Comparaison des coroutines et des threads en langage Go

Dans le langage Go, Goroutine et Thread sont tous deux des mécanismes utilisés pour exécuter du code concurrent. Bien que leurs fonctions soient similaires, il existe quelques différences dans leur mise en œuvre et leur utilisation. Cet article explorera la différence entre les coroutines et les threads dans le langage Go à travers des exemples de code spécifiques et aidera les lecteurs à mieux comprendre les différences entre eux.

1. Les concepts de coroutines et de threads

Les coroutines sont des unités de concurrence légères dans le langage Go et peuvent être considérées comme un thread léger. Les coroutines sont gérées par le runtime Go et disposent d'un petit espace de pile et d'une faible surcharge de création et de destruction, permettant de créer un grand nombre de coroutines pour une exécution simultanée sans se soucier du gaspillage de ressources.

Les threads sont des unités d'exécution simultanées au niveau du système d'exploitation et sont gérés par le noyau du système d'exploitation. Chaque thread possède son propre espace de pile et ses propres registres. La création et la destruction de threads sont coûteuses, il est donc impossible de créer un grand nombre de threads d'exécution simultanés comme les coroutines.

2. Exemple d'utilisation de coroutine

Ce qui suit est un exemple simple de code d'utilisation de coroutine :

package main

import (
    "fmt"
    "time"
)

func printNumbers() {
    for i := 1; i <= 5; i++ {
        fmt.Println(i)
    }
}

func main() {
    go printNumbers()
    
    time.Sleep(1 * time.Second)
    fmt.Println("Main goroutine exits")
}

Dans le code ci-dessus, la fonction printNumbers est démarrée en tant que coroutine, cette fonction sera imprimez les chiffres de 1 à 5. Dans la fonction principale, utilisez le mot-clé go pour démarrer la coroutine printNumbers et laissez la fonction principale attendre 1 seconde pendant le time.Sleep Assurez-vous que la coroutine a suffisamment de temps pour s’exécuter. Enfin, la fonction main affiche "Main goroutine exits". printNumbers函数被启动为一个协程，该函数会打印1到5这几个数字。在主函数中，使用go关键字启动了printNumbers协程，并且通过time.Sleep函数让主函数等待1秒，以确保协程有足够的时间执行。最后主函数输出"Main goroutine exits"。

3. 使用线程的示例

下面是一个简单的使用线程的示例代码：

package main

import (
    "fmt"
    "sync"
)

var wg sync.WaitGroup

func printNumbers() {
    defer wg.Done()

    for i := 1; i <= 5; i++ {
        fmt.Println(i)
    }
}

func main() {
    wg.Add(1)
    go printNumbers()

    wg.Wait()
    fmt.Println("Main thread exits")
}

在上面的代码中，printNumbers函数被启动为一个线程，使用sync.WaitGroup来等待线程的结束。在主函数中，通过wg.Add来添加一个等待的线程，然后通过go关键字启动printNumbers线程。最后通过wg.Wait函数等待线程结束，并输出"Main thread exits"。

4. 区别与总结

从以上的示例可以看出，使用协程需要通过go关键字来启动，并且不需要显式等待协程结束；而使用线程则需使用一些同步机制（比如sync.WaitGroup

3. Exemple d'utilisation de threads

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!