Fonctionnalités du langage Golang révélées : modèle de calcul parallèle et de concurrence

Fonctionnalités du langage Golang révélées : modèle de calcul parallèle et de concurrence

Le langage Go (Golang) est un langage de programmation open source développé par Google et est célèbre pour sa conception simple et efficace et son excellente prise en charge de la concurrence. Dans cet article, nous explorerons les modèles de calcul parallèle et de concurrence de Golang et comment ils peuvent être utilisés pour améliorer les performances de vos programmes.

1. Informatique parallèle

L'informatique parallèle fait référence à la capacité d'effectuer plusieurs tâches informatiques en même temps. Il accélère l'exécution du programme en utilisant plusieurs processeurs ou cœurs de processeur. Dans Golang, nous pouvons utiliser des goroutines et des canaux pour implémenter le calcul parallèle.

1. Goroutine

Goroutine est une unité d'exécution légère dans Golang, qui peut s'exécuter simultanément avec d'autres Goroutines. Par rapport aux threads du système d'exploitation, les Goroutines sont démarrées et détruites plus rapidement et occupent moins de mémoire. Une Goroutine peut être créée en utilisant le mot-clé go.

Voici un exemple de code qui utilise Goroutine pour calculer la séquence de Fibonacci :

package main

import (
    "fmt"
)

func Fibonacci(n int, c chan int) {
    x, y := 0, 1
    for i := 0; i < n; i++ {
        c <- x
        x, y = y, x+y
    }
    close(c)
}

func main() {
    c := make(chan int)
    go Fibonacci(10, c)
    for i := range c {
        fmt.Println(i)
    }
}

Dans l'exemple ci-dessus, nous avons créé un Goroutine pour calculer la séquence de Fibonacci et envoyer les résultats du calcul au thread principal via un canal. Le thread principal lit les données du canal via le mot-clé range et les imprime sur la console.

2. Channel

Channel peut être utilisé comme pipeline pour la communication entre les Goroutines. Il fournit un mécanisme d'accès simultané sécurisé qui empêche plusieurs Goroutines d'accéder et de modifier les données partagées en même temps.

Dans Golang, vous pouvez utiliser la fonction make pour créer une chaîne. Les canaux peuvent être mis en mémoire tampon ou non. Les canaux tamponnés peuvent stocker une certaine quantité de données, tandis que les canaux non tamponnés ne peuvent stocker qu'une seule donnée à la fois.

Voici un exemple de code qui utilise des canaux pour les calculs parallèles :

package main

import (
    "fmt"
    "time"
)

func calculateSquare(number int, c chan int) {
    time.Sleep(1 * time.Second)
    c <- number * number
}

func main() {
    startTime := time.Now()

    c := make(chan int)

    for i := 1; i <= 3; i++ {
        go calculateSquare(i, c)
    }

    for i := 1; i <= 3; i++ {
        fmt.Println(<-c)
    }

    endTime := time.Now()
    elapsedTime := endTime.Sub(startTime)
    fmt.Printf("总计算时间：%s
", elapsedTime)
}

Dans l'exemple ci-dessus, nous créons une fonction qui calcule le carré et envoie le résultat du calcul dans le canal. Ensuite, 3 Goroutines sont créées dans le thread principal pour effectuer des tâches de calcul simultanément, et les résultats sont lus dans le thread principal via le canal pour impression. Enfin, nous utilisons le package time pour calculer et imprimer le temps de calcul total du programme.

2. Modèle de concurrence

La concurrence signifie que plusieurs tâches sont exécutées de manière alternée, mais pas nécessairement en même temps. Un modèle de concurrence est une méthode permettant de gérer et de planifier plusieurs tâches simultanées. Dans Golang, nous pouvons utiliser des verrous mutex (Mutex) et des verrous en lecture-écriture (RWMutex) pour obtenir un accès simultané aux données.

1. Mutex (Mutex)

Mutex est utilisé pour protéger les ressources partagées. Un seul Goroutine est autorisé à accéder aux ressources partagées, et les autres Goroutines doivent attendre la sortie du mutex avant de pouvoir y accéder. Les verrous Mutex peuvent être créés à l'aide du type Mutex du package de synchronisation.

Ce qui suit est un exemple de code qui utilise un mutex pour implémenter un accès simultané aux ressources partagées :

package main

import (
    "fmt"
    "sync"
    "time"
)

var count int
var mutex sync.Mutex

func increment() {
    mutex.Lock()
    defer mutex.Unlock()
    count++
    fmt.Println(count)
}

func main() {
    for i := 0; i < 10; i++ {
        go increment()
    }

    time.Sleep(2 * time.Second)
    fmt.Printf("最终值：%d
", count)
}

Dans l'exemple ci-dessus, nous avons créé un nombre de variables globales et utilisé un mutex pour protéger son accès simultané. Dans chaque Goroutine, utilisez d'abord la méthode Lock pour obtenir le verrouillage mutex, puis utilisez la méthode Unlock pour libérer le verrouillage mutex une fois la fonction terminée. Enfin, nous imprimons la valeur finale du nombre.

2. Verrouillage en lecture-écriture (RWMutex)

Le verrouillage en lecture-écriture est utilisé pour gérer les opérations de lecture et d'écriture sur les ressources partagées. Contrairement à un mutex, plusieurs Goroutines peuvent accéder simultanément à une ressource partagée pour les opérations de lecture, mais pour les opérations d'écriture, un seul Goroutine peut y accéder. Des verrous en lecture-écriture peuvent être créés à l'aide du type RWMutex du package de synchronisation.

Ce qui suit est un exemple de code qui utilise des verrous en lecture-écriture pour implémenter la lecture et l'écriture simultanées de ressources partagées :

package main

import (
    "fmt"
    "sync"
    "time"
)

var count int
var rwMutex sync.RWMutex

func read() {
    rwMutex.RLock()
    defer rwMutex.RUnlock()
    fmt.Println(count)
}

func write() {
    rwMutex.Lock()
    defer rwMutex.Unlock()
    count++
}

func main() {
    for i := 0; i < 10; i++ {
        go read()
        go write()
    }

    time.Sleep(2 * time.Second)
}

Dans l'exemple ci-dessus, nous avons créé un nombre de variables globales et utilisé des verrous en lecture-écriture pour protéger sa lecture simultanée et en écrivant. Dans chaque Goroutine, nous utilisons la méthode RLock pour obtenir le verrou en lecture pour les opérations de lecture, et la méthode Lock pour obtenir le verrou en écriture pour les opérations d'écriture. Enfin, nous utilisons le package time pour nous assurer que Goroutine dispose de suffisamment de temps pour s'exécuter.

Résumé :

Golang fournit une puissante prise en charge du calcul parallèle et des modèles de concurrence, nous permettant de mieux utiliser les performances des processeurs multicœurs et des cœurs de processeur. En utilisant des Goroutines et des canaux pour implémenter le calcul parallèle, nous pouvons implémenter rapidement et facilement des programmes simultanés efficaces. L'utilisation de verrous mutex et de verrous en lecture-écriture pour gérer l'accès simultané aux ressources partagées peut garantir la cohérence et la fiabilité des données. En comprenant et en utilisant le modèle de calcul parallèle et de concurrence de Golang, nous pouvons mieux améliorer les performances et la réactivité de nos programmes.

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!