Conseils pour utiliser les canaux et le mutex dans les fonctions Golang

Golang est un langage de programmation très populaire. Il est largement utilisé dans la programmation réseau, le cloud computing, la programmation simultanée et d'autres domaines. Parmi eux, le canal et le mutex sont des concepts importants dans la programmation Golang. Ils peuvent nous aider à résoudre certains problèmes de programmation simultanée. Cet article expliquera comment utiliser les canaux et le mutex des fonctions Golang.

1. Qu'est-ce qu'une chaîne ?

Dans Golang, le canal est un type de données qui peut être utilisé pour transmettre des données entre différents Goroutines. L'utilisation de canaux peut garantir l'atomicité et la synchronisation de la transmission des données, résolvant ainsi efficacement les problèmes de programmation simultanée.

De manière générale, nous pouvons créer un canal via la fonction make :

ch := make(chan int)

Notez que le canal que nous créons en ce moment est sans tampon, c'est-à-dire que sa capacité est de 0. Par conséquent, si nous envoyons des données sur ce canal, il doit y avoir un Goroutine qui reçoit les données.

Nous pouvons envoyer des données au canal de la manière suivante :

ch <- data

Où, les données sont les données que nous voulons envoyer. Il convient de noter que si aucun Goroutine ne reçoit de données à ce moment-là, le Goroutine envoyant des données sera bloqué.

Et si nous voulons recevoir des données de la chaîne, nous pouvons utiliser la méthode suivante :

data := <-ch

Ici, les données sont les données reçues. Il convient de noter que si aucun Goroutine n'envoie de données à ce moment-là, le Goroutine recevant les données sera bloqué.

Ce qui précède correspond à l'utilisation de base de la chaîne. Ensuite, nous utiliserons un exemple pour comprendre plus en profondeur comment utiliser les canaux.

Supposons que nous ayons un tableau, que nous voulions mettre chaque élément au carré, puis afficher le résultat. Si nous utilisons une boucle for pour l'implémenter, le code peut être le suivant :

func main() {
    arr := [...]int{1, 2, 3, 4, 5}
    for _, v := range arr {
        fmt.Println(v*v)
    }
}

Ce code est très simple, mais il est exécuté en série et est très inefficace. Si nous voulons paralléliser ce processus, nous pouvons utiliser des Goroutines et des canaux :

func main() {
    arr := [...]int{1, 2, 3, 4, 5}
    ch := make(chan int)
    for _, v := range arr {
        go func(a int) {
            ch <- a * a
        }(v)
    }
    for range arr {
        fmt.Println(<-ch)
    }
}

Ici, nous créons d'abord un canal, puis utilisons une boucle for pour parcourir chaque élément du tableau et envoyer le résultat au canal via une fonction anonyme. milieu. Enfin, nous utilisons à nouveau la boucle for pour recevoir les résultats dans le canal. Ici, nous pouvons utiliser range arr pour recevoir toutes les données dans arr.

Il est à noter que les opérations d'envoi et de réception des chaînes sont bloquantes. Par conséquent, s'il n'y a pas de données dans le canal, le Goroutine recevant le canal sera bloqué, et le Goroutine envoyant le canal sera également bloqué jusqu'à ce qu'un Goroutine puisse recevoir des données.

2. Qu'est-ce que le mutex ?

En programmation simultanée, nous devons parfois gérer certaines ressources partagées (comme un tableau partagé), et plusieurs Goroutines peuvent accéder à la ressource en même temps, ce qui peut causer des problèmes, comme une course aux données.

Pour résoudre ce problème, nous pouvons utiliser mutex. Dans Golang, nous pouvons représenter un verrou mutex via le type sync.Mutex.

Ce qui suit est un exemple d'utilisation de base d'un verrou mutex :

var mu sync.Mutex
var count int
func main() {
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            mu.Lock()
            count++
            mu.Unlock()
            wg.Done()
        }()
    }
    wg.Wait()
    fmt.Println(count)
}

Dans ce code, nous définissons d'abord un verrou mutex mu et un compteur. Dans la boucle for, nous avons créé 1000 Goroutines. Chaque Goroutine incrémentera d'abord le nombre de un, puis obtiendra le verrou mutex via la méthode Lock (si le verrou est déjà occupé à ce moment, le Goroutine sera bloqué après le). La valeur du nombre est mise à jour, le verrou mutex est libéré via la méthode Unlock. Enfin, nous utilisons sync.WaitGroup pour attendre que toutes les Goroutines se terminent et génèrent la valeur de count.

Il convient de noter que lors de l'utilisation de verrous mutex, nous devons être particulièrement prudents. Il est préférable d'opérer immédiatement après le verrouillage et de libérer le verrou dès que possible une fois l'opération terminée pour éviter de maintenir le verrou trop longtemps et de provoquer des dommages. d'autres problèmes. Le temps d'attente de Goroutine est trop long.

3. Conseils pour l'utilisation des canaux et des mutex

Lors de l'utilisation des canaux et des mutex, nous devons faire attention aux points suivants :

1. Éviter les blocages

Lors de l'utilisation des mutex, nous devons faire attention pour éviter les blocages. Si plusieurs Goroutines tentent d'obtenir des verrous en même temps et que les dépendances entre eux sont inappropriées, des problèmes de blocage peuvent survenir. Par conséquent, nous devons concevoir le code avec soin pour éviter les situations de blocage.

2. Éviter le gaspillage de ressources

Lors de l'utilisation des canaux, nous devons faire attention à éviter le gaspillage de ressources. Si nous créons un canal sans tampon et ne transmettons pas les données à temps, cela peut entraîner le blocage de Goroutine et gaspiller les ressources du système. Par conséquent, nous devons sélectionner avec soin la capacité du canal et transmettre les données en temps opportun.

3. Optimisation de la concurrence

Lors de l'utilisation de canaux et de mutex, nous devons faire attention à l'optimisation de la concurrence. Si nous utilisons trop de canaux ou de verrous mutex, l'efficacité du programme peut diminuer. Par conséquent, nous devons sélectionner soigneusement le nombre de canaux et de verrous mutex en fonction de la situation réelle, et optimiser la logique du code pour réduire autant que possible la concurrence entre les verrous.

4.Résumé

Cet article présente les techniques d'utilisation du canal et du mutex dans les fonctions Golang, y compris l'utilisation de base du canal, l'utilisation de base du mutex et les techniques d'utilisation. Lors de l'écriture de programmes concurrents efficaces, l'utilisation de canaux et de mutex est devenue un outil indispensable dans la programmation Golang. En comprenant en profondeur ces deux concepts importants et en utilisant des techniques de programmation plus efficaces, nous pouvons nous aider à mieux relever les différents défis de la programmation simultanée.

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!