Comprendre les Goroutines

Go se démarque par sa capacité à créer des applications concurrentes de manière simple et efficace. L’une des fonctionnalités qui permettent d’atteindre cet objectif est Goroutines, l’une des fonctionnalités les plus puissantes du langage. Si vous avez travaillé avec d'autres langages, vous êtes probablement familier avec les fils de discussion, mais les Goroutines sont différentes.

Que sont les Goroutines ?

En bref, ce sont des fonctions ou des méthodes qui s'exécutent simultanément avec d'autres fonctions ou méthodes. Ils sont plus légers que les threads du système d'exploitation, vous pouvez donc créer des milliers de Goroutines avec beaucoup moins de frais généraux.

Que sont les Threads et pourquoi les Goroutines peuvent-elles être plus légères ?

Les threads sont essentiellement des unités d'exécution au sein d'un processus. Un processus peut avoir plusieurs threads, partageant tous le même espace mémoire mais avec leur propre pile d'exécution, qui est essentiellement une structure de données qui stocke des informations sur les fonctions actives dans un programme. Les threads du système d'exploitation sont gérés et mis à l'échelle par le système d'exploitation et ont également une limite pratique de milliers de threads par processus et une taille de pile fixe (généralement 1 Mo ou plus par thread).

Les Goroutines sont des "threads verts" ou des threads au niveau utilisateur, gérés par le runtime Go, la taille de la pile dynamique commence à seulement 2 Ko et peut s'étendre ou diminuer selon les besoins. C'est pourquoi les Goroutines peuvent être plus légères.

Qu'est-ce que la concurrence et quelle est la différence avec le parallélisme ?

La concurrence est le fait de traiter plusieurs tâches en même temps, tandis que le parallélisme exécute des tâches simultanément sur plusieurs processeurs. Un peu déroutant, mais vous comprendrez mieux maintenant : la compétition implique plus de structure et d'organisation. Voir l'exemple ci-dessous :

Le parallélisme implique davantage d'exécutions, s'exécutant en même temps, voir l'exemple ci-dessous :

Que sont les chaînes ?

Les canaux sont des "canaux" de communication entre Goroutines. Ils permettent aux Goroutines de communiquer et de synchroniser leur exécution. Exemple de communication entre Goroutines utilisant des canaux :

func main() {
    ch := make(chan string)

    go func() {
        ch <- "Mensagem da goroutine"
    }()

    msg := <-ch
    fmt.Println(msg)
}

Terminons maintenant avec des exemples d'utilisation des Goroutines :

// 1. Fazendo café e torrada ao mesmo tempo
func cafeDaManha() {
   fmt.Println("Iniciando café da manhã...") // 1º: Aparece primeiro

   go fazerCafe()    // 2º: "Começando a fazer café..."
   go fazerTorrada() // 3º: "Começando a fazer torrada..."

   // Espera 5 segundos para tudo ficar pronto
   time.Sleep(5 * time.Second)
   fmt.Println("Café da manhã pronto!") // Último: Aparece depois de 5 segundos
}

func fazerCafe() {
   fmt.Println("Começando a fazer café...")
   time.Sleep(3 * time.Second) 
   fmt.Println("Café pronto!") // 4º: Aparece após 3 segundos
}

func fazerTorrada() {
   fmt.Println("Começando a fazer torrada...")
   time.Sleep(2 * time.Second)
   fmt.Println("Torrada pronta!") // 5º: Aparece após 2 segundos
}

/* Saída:
Iniciando café da manhã...
Começando a fazer café...
Começando a fazer torrada...
Torrada pronta! (após 2 segundos)
Café pronto! (após 3 segundos)
Café da manhã pronto! (após 5 segundos)
*/

// 2. Contagem com Goroutines
func contagem() {
   go contar("A", 5) // Começa a contar imediatamente
   go contar("B", 5) // Começa a contar imediatamente

   time.Sleep(6 * time.Second)
}

func contar(nome string, até int) {
   for i := 1; i <= até; i++ {
       fmt.Printf("%s: %d\n", nome, i)
       time.Sleep(1 * time.Second)
   }
}

/* Saída (aproximada - as linhas A e B se misturam):
A: 1
B: 1
A: 2
B: 2
A: 3
B: 3
A: 4
B: 4
A: 5
B: 5
*/

// 3. Enviando mensagens simples
func mensagens() {
   canal := make(chan string)

   go func() {
       canal <- "Olá!"      // 1ª mensagem enviada
       canal <- "Tudo bem?" // 2ª mensagem enviada
       canal <- "Tchau!"    // 3ª mensagem enviada
   }()

   fmt.Println(<-canal) // 1º: Imprime "Olá!"
   fmt.Println(<-canal) // 2º: Imprime "Tudo bem?"
   fmt.Println(<-canal) // 3º: Imprime "Tchau!"
}

/* Saída:
Olá!
Tudo bem?
Tchau!
*/

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!