remplacement atomique de Golang

Golang est un langage de programmation développé par Google Il possède des fonctions très puissantes en programmation concurrente. L'une d'elles concerne les opérations atomiques, qui garantissent l'exactitude des ressources partagées dans un environnement multithread. Dans Golang, les opérations atomiques sont fournies par le package sync/atomic Cet article présentera en détail l'opération de remplacement atomique.

Avant d’introduire la substitution atomique, comprenons d’abord ce que sont les opérations atomiques. Dans la programmation multithread, si plusieurs threads doivent accéder à une ressource partagée en même temps, certains problèmes surviendront si l'accès n'est pas coordonné. Par exemple, si plusieurs threads tentent de modifier la même valeur en même temps, une condition de concurrence critique peut se produire, provoquant des erreurs de programme ou un comportement imprévisible.

Pour résoudre ce problème, nous pouvons utiliser une technique appelée opérations atomiques. Une opération atomique est une opération indivisible qui ne peut être interrompue ou modifiée en cours d'exécution. Cela évite les conditions de concurrence provoquées par plusieurs threads accédant simultanément à des ressources partagées. Golang fournit certaines fonctions d'opération atomique, telles que AddInt32, AddInt64, CompareAndSwapInt32, etc.

Les fonctions d'opération de remplacement atomique sont SwapInt32, SwapInt64, SwapUint32, SwapUint64 et SwapPointer. En prenant SwapInt32 comme exemple, son prototype de fonction est le suivant :

func SwapInt32(addr *int32, new int32) (old int32)

Cette fonction reçoit un pointeur vers une variable de type int32 et une nouvelle valeur int32, et elle essayez de La valeur à l'adresse mémoire pointée par le pointeur est remplacée par la nouvelle valeur et la valeur d'origine est renvoyée. Si le remplacement échoue en raison d'une modification simultanée, la valeur d'origine est renvoyée. Cette fonction est atomique, même si plusieurs threads appellent SwapInt32 en même temps pour modifier la même valeur, il n'y aura aucun problème.

Regardons un exemple simple ci-dessous. Le compteur dans l'exemple est une variable de type int32, et plusieurs threads tenteront d'augmenter sa valeur de 1 en même temps. Si vous n'utilisez pas d'opérations de remplacement atomique, vous devez utiliser des verrous pour garantir que plusieurs threads ne modifient pas le compteur en même temps, ce qui entraînerait une dégradation des performances. Avec les opérations de remplacement atomique, aucun verrou n’est requis. Le code est le suivant :

package main

import (
    "fmt"
    "sync/atomic"
    "time"
)

func main() {
    var counter int32
    
    for i := 1; i <= 10; i++ {
        go func() {
            for {
                oldValue := atomic.LoadInt32(&counter)
                if atomic.CompareAndSwapInt32(&counter, oldValue, oldValue+1) {
                    break
                }
                time.Sleep(time.Millisecond)
            }
        }()
    }
    
    time.Sleep(time.Second * 1)
    
    fmt.Println(counter)
}

Dans cet exemple, nous avons fixé la valeur initiale du compteur à 0 et avons démarré 10 goroutines pour y ajouter 1. Dans chaque goroutine, nous utilisons une boucle for pour essayer en permanence d'incrémenter la valeur du compteur de 1. La fonction LoadInt32 est utilisée ici pour lire la valeur du compteur, et la fonction CompareAndSwapInt32 est utilisée pour effectuer des opérations de remplacement atomique. Ici, oldValue est utilisée comme valeur de base pour la comparaison. Si la valeur du compteur actuel est la même que oldValue, une opération de remplacement atomique est effectuée. Si le remplacement réussit, quittez la boucle ; si le remplacement échoue, attendez un moment et réessayez.

Dans cet exemple, une condition de concurrence possible est que plusieurs goroutines lisent la valeur du compteur comme k en même temps, puis y ajoutent 1 en même temps, ce qui fait que le compteur n'ajoute que 1. Cependant, en raison de l'utilisation d'opérations de remplacement atomique, chaque goroutine ne fonctionnera que lorsqu'elle tentera de modifier le compteur. Les autres threads ne peuvent pas modifier le compteur, donc aucune condition de concurrence ne se produira. La valeur finale du compteur émise par le programme doit être 10, et le résultat est généralement comme ceci.

Cet article présente les fonctions d'opération de remplacement atomique dans Golang, notamment SwapInt32, SwapInt64, SwapUint32, SwapUint64 et SwapPointer. Les opérations atomiques sont un moyen important de garantir l'exactitude des ressources partagées dans la programmation multithread et peuvent éviter les conditions de concurrence. Golang fournit certaines fonctions d'opération atomique pour implémenter des fonctions telles que les verrous de rotation et les opérations CAS. Les programmeurs peuvent choisir des fonctions d'opération atomique appropriées pour résoudre les problèmes de 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!