Analyse approfondie des principes et des applications des serrures à Golang

Analyse du principe et de l'application des verrous dans Golang

1. Introduction
   Dans la programmation simultanée, nous rencontrons souvent des situations où plusieurs goroutines accèdent aux ressources partagées en même temps. Une fois que plusieurs goroutines lisent et écrivent des ressources partagées en même temps, cela se produit. peut conduire à une incohérence des données ou à des conditions de concurrence. Afin de résoudre ce problème, Golang fournit un mécanisme de verrouillage pour protéger l'accès aux ressources partagées et garantir qu'une seule goroutine peut effectuer des opérations de lecture et d'écriture en même temps.
2. Le principe du verrouillage
   Golang fournit le package de synchronisation pour implémenter la fonction de verrouillage. Les verrous couramment utilisés incluent le verrouillage mutex Mutex et le verrouillage en lecture-écriture RWMutex. Les verrous mutex sont utilisés pour protéger les opérations de lecture et d'écriture sur les ressources partagées. Comme leur nom l'indique, les verrous de lecture sont utilisés pour protéger les opérations de lecture et les verrous d'écriture sont utilisés pour protéger les opérations d'écriture.

2.1 Verrouillage mutex
Le principe de base du verrouillage mutex est d'utiliser un bit d'indicateur pour indiquer si la ressource est verrouillée. Lorsqu'une goroutine souhaite accéder à une ressource protégée par un mutex, elle tentera d'abord d'acquérir le verrou. Si le verrou a été acquis par un autre goroutine, le goroutine actuel sera bloqué jusqu'à ce que le verrou soit libéré. Lorsqu'une goroutine acquiert le verrou, elle peut opérer sur la ressource et libérer le verrou une fois l'opération terminée afin que d'autres goroutines puissent acquérir le verrou.

Ce qui suit est un exemple d'application d'un verrou mutex :

package main

import (
    "fmt"
    "sync"
)

var count int
var lock sync.Mutex

func increase() {
    for i := 0; i < 100000; i++ {
        lock.Lock()
        count++
        lock.Unlock()
    }
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            increase()
            wg.Done()
        }()
    }
    wg.Wait()
    fmt.Println("count:", count)
}

Dans l'exemple ci-dessus, nous avons créé un verrou mutex lock pour protéger les opérations de lecture et d'écriture de la variable globale count . Ensuite, 10 goroutines sont démarrées pour faire fonctionner la variable <code>count simultanément. Chaque goroutine effectuera 100 000 opérations d'addition sur count. Enfin, affichez la valeur de count, et nous constaterons que le résultat est toujours 1 000 000, indiquant que le verrou mutex garantit effectivement l'exactitude des opérations simultanées. lock 来保护全局变量 count 的读写操作。然后启动了10个 goroutine 来并发操作 count 变量，每个 goroutine 都会对 count 执行 100000 次加操作。最后输出 count 的值，我们会发现结果始终是 1000000，表明互斥锁确实保证了并发操作的正确性。

2.2 读写锁
读写锁是互斥锁的扩展，它允许多个 goroutine 同时读共享资源，并且保证在写资源时只能有一个 goroutine。读写锁可以提高并发处理读操作的效率。

下面是读写锁的应用示例：

package main

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

var count int
var rwlock sync.RWMutex

func read() {
    rwlock.RLock()
    defer rwlock.RUnlock()
    fmt.Println("read:", count)
}

func write() {
    rwlock.Lock()
    defer rwlock.Unlock()
    count = count + 1
    fmt.Println("write:", count)
}

func main() {
    go read()
    go write()

    time.Sleep(time.Second)
}

在上述示例中，我们创建了一个读写锁 rwlock 来保护全局变量 count 的读写操作。启动了两个 goroutine，其中一个进行读操作，另一个进行写操作。由于读操作可以同时进行，因此读操作会先执行，输出 read: 和 write:

2.2 Verrouillage en lecture-écriture

Le verrouillage en lecture-écriture est une extension du verrouillage mutex. Il permet à plusieurs goroutines de lire les ressources partagées en même temps et garantit qu'il ne peut y avoir qu'une seule goroutine lors de l'écriture des ressources. Les verrous en lecture-écriture peuvent améliorer l'efficacité du traitement simultané des opérations de lecture.
3. Ce qui suit est un exemple d'application d'un verrou en lecture-écriture :
4. rrreee
Dans l'exemple ci-dessus, nous avons créé un verrou en lecture-écriture rwlock pour protéger les opérations de lecture et d'écriture de la variable globale compte . Deux goroutines sont démarrées, une pour la lecture et l'autre pour l'écriture. Étant donné que les opérations de lecture peuvent être effectuées en même temps, les opérations de lecture seront exécutées en premier et l'ordre de sortie read: et write: peut être différent. Mais nous pouvons garantir que l'opération d'écriture est effectuée en premier, puis l'opération de lecture est effectuée pour garantir l'exactitude des données.
6. Remarques
   
Lors de l'utilisation de verrous, vous devez éviter les blocages, c'est-à-dire lorsque plusieurs goroutines s'attendent pour libérer le verrou en même temps et ne peuvent pas continuer l'exécution. Pour éviter une impasse, un report peut être utilisé pour garantir que le verrou est libéré.

🎜Les verrous ont une certaine surcharge, notamment pour un grand nombre d'opérations de lecture simultanées. Par conséquent, il existe un compromis entre performances et exactitude lors de l’utilisation des verrous. 🎜🎜Résumé🎜Le mécanisme de verrouillage de Golang est un moyen couramment utilisé dans la programmation simultanée. Grâce aux verrous d'exclusion mutuelle et aux verrous en lecture-écriture, nous pouvons garantir l'exactitude et l'efficacité de l'accès aux ressources partagées, évitant ainsi les incohérences des données et les conditions de concurrence. problèmes. Lorsque vous utilisez des verrous, vous devez veiller à éviter les blocages et à peser les besoins de performance et d'exactitude. 🎜🎜

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!