Quelle est la méthode d'écriture parallèle en golang ?

Dans le développement de logiciels modernes, une utilisation efficace des ressources matérielles informatiques est cruciale. La programmation parallèle est une méthode de programmation permettant d'optimiser l'utilisation des processeurs multicœurs. Comparé à d'autres langages de programmation, le langage Go (également appelé Golang) possède des outils et des mécanismes intégrés pour prendre en charge la programmation simultanée, il a donc été largement utilisé et reconnu dans le domaine de la programmation parallèle.

Cet article présentera quelques méthodes et techniques pour implémenter la programmation parallèle dans Golang, ainsi que leurs scénarios et précautions applicables.

1. Goroutine et Channel

Goroutine est un modèle de programmation parallèle que Golang emprunte à d'autres langages de programmation. Connu sous le nom de threads légers, il utilise plus efficacement la puissance de traitement multicœur de votre ordinateur. Chaque Goroutine est automatiquement gérée par le système d'exécution de Golang, et les développeurs n'ont qu'à créer une Goroutine en exécutant le mot-clé go.

Par exemple :

func main() {
    go func() {
        fmt.Println("Hello, Goroutine!")
    }()
    fmt.Println("Hello, World!")
}

Dans ce code, nous créons une fonction anonyme et la convertissons en Goroutine à l'aide du mot-clé go. Le programme affichera « Hello, World ! » et « Hello, Goroutine ! » en même temps.

Channel est le mécanisme de Golang pour la communication entre les Goroutines. Le canal peut être utilisé pour transmettre tout type de données, de sorte que les données et les informations de contrôle peuvent être transmises entre différents Goroutines.

Par exemple :

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Println("worker", id, "started  job", j)
        time.Sleep(time.Second)
        fmt.Println("worker", id, "finished job", j)
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }
    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)
    for a := 1; a <= 9; a++ {
        <-results
    }
}

Dans ce code, nous définissons une fonction de travail qui reçoit deux canaux : un pour recevoir les tâches et l'autre pour renvoyer les résultats des tâches. Nous avons créé trois Goroutines. Chaque Goroutine obtiendra les tâches du canal des tâches et écrira les résultats du traitement dans le canal des résultats. Enfin, nous utilisons une boucle for pour envoyer 9 tâches au canal des tâches et afficher les valeurs du canal des résultats sur la sortie standard. Notez que nous devons fermer le canal jobs après la boucle for afin que la fonction de travail se termine.

2. Package Sync

Dans Golang, le package Sync fournit certains outils de synchronisation nécessaires à la programmation parallèle, tels que :

· WaitGroup : attendez qu'un groupe de Goroutines termine des tâches
· Mutex : implémentez l'exclusion mutuelle des tâches partagées ; Accès aux données ;
· Cond : variable de condition, utilisée pour la communication et la synchronisation entre plusieurs Goroutines.

Ici, nous allons montrer un exemple d'utilisation de WaitGroup :

func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("Worker %d starting\n", id)

    time.Sleep(time.Second)
    fmt.Printf("Worker %d done\n", id)
}

func main() {
    var wg sync.WaitGroup

    for i := 1; i <= 5; i++ {
        wg.Add(1)
        go worker(i, &wg)
    }

    wg.Wait()
}

Dans cet exemple, nous définissons une fonction de travail qui reçoit un pointeur WaitGroup en tant que paramètre. Une fois le travail de la fonction terminé, nous appelons la méthode Done de WaitGroup pour informer que la tâche Goroutine à laquelle elle appartient est terminée. Dans la fonction principale, nous créons un Goroutine pour chaque fonction de travail et utilisons la méthode Add de WaitGroup pour indiquer à WaitGroup qu'un groupe de Goroutines s'exécute ici. Enfin, nous appelons la méthode Wait pour attendre que tous les Goroutines terminent leurs tâches.

3. Définir GOMAXPROCS

Dans Golang, GOMAXPROCS est un nombre indiquant combien de Goroutines doivent s'exécuter en même temps. Si ce nombre est trop petit, le parallélisme du programme sera limité. Si la valeur est trop grande, les ressources informatiques seront gaspillées. Par conséquent, nous devons définir la valeur de GOMAXPROCS en fonction du nombre de cœurs de processeur de l'ordinateur pour éviter une utilisation excessive ou sous-utilisée des ressources de l'ordinateur.

Par défaut, le GOMAXPROCS de Golang est égal au nombre de cœurs de processeur. Vous pouvez utiliser le package d'exécution pour le modifier dans le code du programme :

import "runtime"

//...

func main() {
    numCPU := runtime.NumCPU()
    runtime.GOMAXPROCS(numCPU)

    //...
}

Ici, nous utilisons le package d'exécution pour obtenir le nombre de cœurs de processeur, puis définissez la valeur de GOMAXPROCS égale au nombre de cœurs.

Résumé

Cet article présente plusieurs méthodes et techniques de programmation simultanée dans Golang, notamment Goroutine et Channel, le package Sync et la configuration de GOMAXPROCS. Bien que la programmation simultanée puisse améliorer les performances et l’efficacité des programmes, elle comporte également certains risques et défis. Par conséquent, lors de l'exécution de la programmation simultanée, nous devons choisir une solution appropriée en fonction de la situation réelle et veiller à contrôler le degré de parallélisme pour éviter les erreurs inutiles et le gaspillage de ressources.

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!