Familiarisé avec les mécanismes de verrouillage et de mutex en langage Go

Le langage Go est un langage de programmation très populaire, notamment en programmation concurrente. Et lorsqu’il s’agit de programmation concurrente, les verrous et les mécanismes d’exclusion mutuelle sont inévitables. Cet article présentera le mécanisme de verrouillage et d'exclusion mutuelle en langage Go.

1. Verrouillage Mutex

Le verrouillage Mutex est le mécanisme de verrouillage le plus basique et est également largement utilisé dans le langage Go. Dans certains cas, plusieurs goroutines peuvent accéder aux variables partagées en même temps. Dans ce cas, nous devons utiliser un verrou mutex pour empêcher une seule goroutine d'accéder aux variables partagées en même temps.

Dans le langage Go, l'utilisation des verrous mutex est très simple. Il suffit d'ajouter mutex.Lock() et mutex.Unlock(), où mutex est une variable de type <code>sync.Mutex. mutex.Lock() 和 mutex.Unlock() 即可，其中 mutex 是一个 sync.Mutex 类型的变量。

在下面的示例代码中，我们模拟了多个 goroutine 同时访问一个共享变量，这时候，互斥锁可以保证同一时刻只有一个 goroutine 能够修改变量值。

package main

import (
    "fmt"
    "sync"
)

var count int
var mutex sync.Mutex

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

func increment() {
    for i := 0; i < 10000; i++ {
        mutex.Lock()
        count++
        mutex.Unlock()
    }
}

二、读写锁

在上面的示例中，我们采用互斥锁来限制共享变量的访问。但是，在某些情况下，读操作比写操作更加频繁，这时候，使用互斥锁会导致读取性能下降，因为互斥锁会阻塞其他 goroutine 的读和写操作。

为了解决这个问题，Go 语言提供了一种特殊的锁机制，叫做读写锁。读写锁可以同时支持多个 goroutine 进行读操作，但是在写操作进行的时候，必须排斥所有的读和写操作。

在 Go 语言中，读写锁的使用也非常简单。我们只需要在需要保护的代码段前后分别加上 rwlock.RLock() 和 rwlock.RUnlock() 用于读操作，加上 rwlock.Lock() 和 rwlock.Unlock() 用于写操作。其中 rwlock 是一个 sync.RWMutex 类型的变量。

下面的示例演示了多个 goroutine 同时读取一个共享变量的情况，我们使用了读写锁来保证高效的读取操作。

package main

import (
    "fmt"
    "sync"
)

var count int
var rwlock sync.RWMutex

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

func read() {
    for i := 0; i < 10000; i++ {
        rwlock.RLock()
        fmt.Println(count)
        rwlock.RUnlock()
    }
}

三、原子操作

在某些情况下，我们只需要进行简单的加减操作，这时候可以通过原子操作来实现。原子操作可以保证这些简单的操作在多个 goroutine 中的执行顺序是稳定的，从而避免了出现竞态条件。

在 Go 语言中，原子操作可以通过 sync/atomic 包中的一些函数来实现。例如，atomic.AddInt32(&count, 1)

Dans l'exemple de code ci-dessous, nous avons simulé plusieurs goroutines accédant à une variable partagée en même temps. À ce stade, le verrouillage mutex peut garantir qu'une seule goroutine peut modifier la valeur de la variable en même temps.

package main

import (
    "fmt"
    "sync/atomic"
)

var count int32

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

func increment() {
    for i := 0; i < 10000; i++ {
        atomic.AddInt32(&count, 1)
    }
}

2. Verrouillage en lecture-écriture

Dans l'exemple ci-dessus, nous utilisons un verrou mutex pour restreindre l'accès aux variables partagées. Cependant, dans certains cas, les opérations de lecture sont plus fréquentes que les opérations d'écriture. Dans ce cas, l'utilisation d'un verrou mutex entraînera de mauvaises performances de lecture car le verrou mutex bloquera d'autres opérations de lecture et d'écriture goroutine. 🎜🎜Pour résoudre ce problème, le langage Go fournit un mécanisme de verrouillage spécial appelé verrouillage en lecture-écriture. Les verrous en lecture-écriture peuvent prendre en charge plusieurs goroutines pour les opérations de lecture en même temps, mais lorsque les opérations d'écriture sont en cours, toutes les opérations de lecture et d'écriture doivent être exclues. 🎜🎜Dans le langage Go, l'utilisation des verrous en lecture-écriture est également très simple. Il suffit d'ajouter rwlock.RLock() et rwlock.RUnlock() avant et après le segment de code qui doit être protégé pour les opérations de lecture, et d'ajouter rwlock.Lock() et rwlock.Unlock() sont utilisés pour les opérations d'écriture. Où rwlock est une variable de type sync.RWMutex. 🎜🎜L'exemple suivant montre la situation dans laquelle plusieurs goroutines lisent une variable partagée en même temps. Nous utilisons des verrous en lecture-écriture pour garantir des opérations de lecture efficaces. 🎜rrreee🎜3. Opérations atomiques🎜🎜Dans certains cas, nous n'avons besoin d'effectuer que des opérations d'addition et de soustraction simples, qui peuvent être réalisées grâce à des opérations atomiques. Les opérations atomiques peuvent garantir que l'ordre d'exécution de ces opérations simples dans plusieurs goroutines est stable, évitant ainsi les conditions de concurrence. 🎜🎜En langage Go, les opérations atomiques peuvent être implémentées via certaines fonctions du package sync/atomic. Par exemple, atomic.AddInt32(&count, 1) Cette fonction peut ajouter 1 à la variable count via une addition atomique. 🎜🎜L'exemple suivant montre comment utiliser des opérations atomiques pour incrémenter en toute sécurité la valeur d'une variable dans plusieurs goroutines. 🎜rrreee🎜Pour résumer, le langage Go fournit une variété de verrous et de mécanismes d'exclusion mutuelle pour protéger l'accès aux variables partagées, et prend également en charge les opérations atomiques pour éviter les conditions de concurrence. Il est très important que les développeurs du langage Go se familiarisent avec l’utilisation de ces mécanismes. 🎜

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!