Idées et méthodes d'optimisation des Goroutines dans la pratique de la programmation simultanée Golang

Idées et méthodes d'optimisation des Goroutines dans la pratique de programmation simultanée Golang

Introduction :
Avec le développement continu du matériel informatique, les processeurs monocœur ne peuvent plus répondre aux exigences actuelles en matière de traitement de données à grande échelle et de besoins de concurrence. La programmation simultanée devient donc de plus en plus importante. En tant que langage prenant en charge la programmation simultanée, les Goroutines et les mécanismes de canal intégrés de Golang fournissent des outils puissants pour la programmation simultanée. Cependant, en raison de la surcharge de commutation élevée des Goroutines de Golang, si les Goroutines sont utilisées sans optimisation, cela entraînera un goulot d'étranglement en termes de performances. Cet article explorera les idées et méthodes d'optimisation des Goroutines dans Golang.

1. Utilisation de base des Goroutines
Dans Golang, vous pouvez créer une Goroutine via le mot-clé "go". Voici un exemple simple :

package main

import (
    "fmt"
)

func main() {
    go hello()
    fmt.Println("main function")
}

func hello() {
    fmt.Println("Hello, Goroutine!")
}

Dans le code ci-dessus, une Goroutine est démarrée par go hello(). Goroutine est exécuté en parallèle avec le thread principal, vous pouvez donc voir que « Bonjour, Goroutine ! » et « fonction principale » apparaissent alternativement dans la sortie.

2. Idées et méthodes d'optimisation des Goroutines

1. Réduire le nombre de créations et les temps de changement des Goroutines
   La création et le changement de Goroutines entraîneront une certaine surcharge, donc réduire le nombre de créations et les temps de changement de Goroutines est une idée d'optimisation. Ceci peut être réalisé en :
2. Consolidez les petites tâches ou calculs dans un seul Goroutine pour éviter la création et le changement excessifs de Goroutines.
3. Utilisez sync.WaitGroup pour attendre que toutes les Goroutines terminent leur exécution avant de passer à l'étape suivante.

Ce qui suit est un exemple de code :

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(2)
    go func() {
        defer wg.Done()
        for i := 0; i < 1000; i++ {
            fmt.Println("Goroutine1: ", i)
        }
    }()

    go func() {
        defer wg.Done()
        for i := 0; i < 1000; i++ {
            fmt.Println("Goroutine2: ", i)
        }
    }()

    wg.Wait()
    fmt.Println("main function")
}

Dans le code ci-dessus, sync.WaitGroup est utilisé pour attendre la fin des deux Goroutines avant d'exécuter le thread principal. En fusionnant les tâches en un petit nombre de Goroutines et en utilisant sync.WaitGroup pour les exécuter de manière synchrone, le nombre de créations et de commutations de Goroutines peut être réduit.

2. Utiliser le pool Goroutines
   La création et la destruction de Goroutines entraîneront une surcharge supplémentaire, vous pouvez donc utiliser le pool Goroutines pour réutiliser les Goroutines existantes afin d'éviter la création et la destruction fréquentes de Goroutines. Le pooling de Goroutines peut être implémenté à l'aide de canaux. Voici un exemple de code :

package main

import (
    "fmt"
)

func main() {
    pool := make(chan bool, 10) // 创建一个容量为10的Goroutines池
    for i := 0; i < 1000; i++ {
        pool <- true
        go func(n int) {
            defer func() {
                <-pool
            }()
            fmt.Println("Goroutine: ", n)
        }(i)
    }

    for i := 0; i < cap(pool); i++ {
        pool <- true
    }

    fmt.Println("main function")
}

Dans le code ci-dessus, un pool Goroutines d'une capacité de 10 est créé. Après l'exécution de chaque Goroutine, un sémaphore sera libéré via le canal, indiquant que le Goroutine est disponible. En réutilisant les Goroutines existantes, le nombre de créations et de destructions de Goroutines peut être réduit.

3. Division des tâches et communication des données
   La division raisonnable des tâches, la coordination et la communication des données sont également une méthode d'optimisation des Goroutines. En divisant les tâches, les tâches volumineuses peuvent être décomposées en plusieurs petites tâches pour améliorer les performances de simultanéité. Dans le même temps, grâce au mécanisme de canal fourni par Golang, la communication de données entre différents Goroutines peut être réalisée. Voici un exemple de code :

package main

import (
    "fmt"
)

func main() {
    tasks := make(chan int, 100) // 创建一个容量为100的任务通道
    results := make(chan int, 100) // 创建一个容量为100的结果通道

    go produceTasks(tasks) // 生成任务
    for i := 0; i < 10; i++ {
        go consumeTasks(tasks, results) // 消费任务
    }

    showResults(results) // 显示结果
    fmt.Println("main function")
}

func produceTasks(tasks chan<- int) {
    for i := 0; i < 100; i++ {
        tasks <- i
    }
    close(tasks)
}

func consumeTasks(tasks <-chan int, results chan<- int) {
    for task := range tasks {
        results <- task * task
    }
}

func showResults(results <-chan int) {
    for result := range results {
        fmt.Println("Result: ", result)
    }
}

Dans le code ci-dessus, 100 tâches sont générées via la fonction ProduceTasks() et envoyées au canal des tâches, puis les tâches sont obtenues à partir du canal des tâches via les Goroutines des consommateurs (consumeTasks() fonction) et Traiter et envoyer les résultats au canal de résultats. Enfin, tous les résultats sont affichés dans la fonction showResults(). Grâce à la division des tâches et à la communication des données, les performances de concurrence et la lisibilité du code peuvent être améliorées.

Résumé : 
La programmation simultanée de Golang est l'une de ses fonctionnalités importantes. Grâce à l'utilisation raisonnable des Goroutines et des mécanismes de canal, la programmation simultanée peut être réalisée efficacement. Cet article présente l'utilisation de base, les idées et les méthodes d'optimisation des Goroutines, notamment la réduction du nombre de Goroutines et les temps de commutation, l'utilisation des pools Goroutines, ainsi que les méthodes de division des tâches et de communication de données. J'espère que cela aidera les développeurs à mieux comprendre et utiliser la programmation simultanée de 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!