Application de verrouillage en programmation concurrente en langage Go

Le langage Go est un langage de programmation open source développé à l'origine par Google pour améliorer l'efficacité des programmeurs et les performances du système. Le langage Go prend en charge la programmation simultanée, ce qui signifie l'exécution de plusieurs tâches en même temps. L'utilisation de verrous est un moyen courant de garantir la sécurité de la concurrence. Dans cet article, nous explorerons comment utiliser les verrous dans le langage Go pour garantir l'exactitude des programmes concurrents et donnerons des exemples de code spécifiques.

Pourquoi les verrous sont nécessaires

En programmation simultanée, lorsque plusieurs goroutines (threads légers en langage Go) accèdent à des variables ou des ressources partagées en même temps, une condition de concurrence critique (Race Condition) peut se produire. Les conditions de concurrence peuvent entraîner des incohérences dans les données et même des plantages de programmes. Afin d'éviter que cette situation ne se produise, nous devons utiliser des verrous pour contrôler et protéger les ressources partagées.

Mutex (Mutex)

Mutex est le type de verrouillage le plus courant. Mutex peut garantir qu'une seule goroutine peut accéder aux ressources partagées en même temps. Dans le langage Go, vous pouvez utiliser le type Mutex dans le package sync pour implémenter un verrou mutex. sync包中的Mutex类型来实现互斥锁。

下面是一个简单的示例代码：

package main

import (
    "fmt"
    "sync"
)

var (
    balance int
    mu      sync.Mutex
)

func deposit(amount int) {
    mu.Lock()
    defer mu.Unlock()
    balance += amount
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go func() {
            deposit(10)
            wg.Done()
        }()
    }
    wg.Wait()

    fmt.Println("Final balance:", balance)
}

在上面的代码中，我们定义了一个全局变量balance表示账户余额，以及一个互斥锁mu用来保护balance的访问。deposit函数负责向账户中存入金额，在存款过程中需要先调用mu.Lock()进行加锁，操作完成后再调用mu.Unlock()进行解锁。

在main函数中启动1000个goroutine并发执行存款操作，通过sync.WaitGroup来等待所有goroutine执行完毕，最后打印出最终的账户余额。

读写锁（RWMutex）

除了互斥锁以外，Go语言也提供了读写锁（RWMutex）来实现读多写少的场景。读写锁允许多个goroutine同时读取共享资源，但在有写操作时会阻塞所有的读操作。

下面是一个使用读写锁的示例代码：

package main

import (
    "fmt"
    "sync"
)

var (
    data map[string]string
    mu   sync.RWMutex
)

func readData(key string) string {
    mu.RLock()
    defer mu.RUnlock()
    return data[key]
}

func writeData(key, value string) {
    mu.Lock()
    defer mu.Unlock()
    data[key] = value
}

func main() {
    data = make(map[string]string)
    var wg sync.WaitGroup
    for i := 0; i < 100; i++ {
        wg.Add(1)
        go func() {
            for j := 0; j < 1000; j++ {
                key := fmt.Sprintf("key%d", j)
                value := fmt.Sprintf("value%d", j)
                writeData(key, value)
                fmt.Println(readData(key))
            }
            wg.Done()
        }()
    }
    wg.Wait()
}

在上面的代码中，我们定义了一个data变量作为共享的数据存储，以及一个读写锁mu用来保护对data的并发访问。readData函数用于读取指定key的数据，调用mu.RLock()进行读锁定；writeData函数用于写入key-value数据，调用mu.Lock()进行写锁定。

在main函数中启动100个goroutine并发执行读写操作，并通过fmt.Println

Ce qui suit est un exemple de code simple :

rrreee

Dans le code ci-dessus, nous définissons une variable globale balance pour représenter le solde du compte, et un verrou mutex mu utilisé pour protéger l'accès au solde. La fonction deposit est responsable du dépôt du montant sur le compte. Pendant le processus de dépôt, vous devez d'abord appeler mu.Lock() pour verrouiller, puis appeler mu.Déverrouiller()Déverrouiller. <p></p>Dans la fonction <code>main, démarrez 1000 goroutines pour effectuer des opérations de dépôt simultanément, attendez que toutes les goroutines terminent leur exécution via sync.WaitGroup, et enfin imprimez le solde final du compte . 🎜🎜Verrouillage en lecture-écriture (RWMutex)🎜🎜En plus des verrous mutex, le langage Go fournit également des verrous en lecture-écriture (RWMutex) pour réaliser des scénarios où il y a plus de lecture et moins d'écriture. Les verrous en lecture-écriture permettent à plusieurs goroutines de lire les ressources partagées en même temps, mais bloqueront toutes les opérations de lecture en cas d'opérations d'écriture. 🎜🎜Ce qui suit est un exemple de code utilisant un verrou en lecture-écriture : 🎜rrreee🎜Dans le code ci-dessus, nous définissons une variable data comme stockage de données partagé et un verrou en lecture-écriture mu Utilisé pour protéger l'accès simultané aux données. La fonction readData est utilisée pour lire les données de la clé spécifiée et appelle mu.RLock() pour le verrouillage en lecture ; utilisé pour écrire les données clé-valeur, appelez mu.Lock() pour le verrouillage en écriture. 🎜🎜Démarrez 100 goroutines dans la fonction main pour effectuer simultanément des opérations de lecture et d'écriture, et imprimez chaque donnée lue via fmt.Println. L'utilisation de verrous en lecture-écriture peut améliorer les performances de concurrence du programme et garantir que les opérations de lecture des données ne sont pas bloquées par les opérations d'écriture. 🎜🎜Résumé🎜🎜Grâce à l'introduction de cet article, nous avons appris l'importance de l'utilisation de verrous dans la programmation simultanée en langage Go, et comment utiliser les verrous mutex et les verrous en lecture-écriture pour protéger les ressources partagées et éviter l'apparition de conditions de concurrence. Dans le développement réel, une utilisation raisonnable des verrous peut améliorer les performances de concurrence du programme et garantir l'exactitude du programme. J'espère que cet article pourra aider les lecteurs à mieux comprendre l'application des verrous dans la programmation simultanée en langage Go. 🎜

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!