Comment la fonction de verrouillage dans Golang est-elle implémentée ?

Les verrous du langage Go implémentent un code concurrent synchronisé pour empêcher la concurrence des données : Mutex : verrouillage Mutex, garantissant qu'un seul goroutine acquiert le verrou en même temps, utilisé pour le contrôle des sections critiques. RWMutex : verrouillage en lecture-écriture, qui permet à plusieurs goroutines de lire des données en même temps, mais une seule goroutine peut écrire des données en même temps. Il convient aux scénarios nécessitant une lecture et une écriture fréquentes de données partagées.

Comment le verrouillage dans la fonction Go est-il implémenté ?

Dans Go, les verrous sont principalement utilisés pour synchroniser le code concurrent et empêcher la concurrence de données provoquée par un accès simultané. Le langage Go propose plusieurs types de verrous, chacun avec des caractéristiques et des scénarios d'utilisation différents.

sync.Mutex : Verrouillage Mutexsync.Mutex：互斥锁

互斥锁是一种最基本的锁，它保证同一时间只有一个 goroutine 可以获取锁。使用 Mutex 可以实现对临界区的访问控制。

package main

import (
    "fmt"
    "sync"
)

var counter int
var mutex sync.Mutex

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 500; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            mutex.Lock()
            counter++
            fmt.Printf("Counter: %d\n", counter)
            mutex.Unlock()
        }()
    }
    wg.Wait()
}

sync.RWMutex

Le verrouillage Mutex est le verrouillage le plus basique, qui garantit qu'un seul goroutine peut acquérir le verrou en même temps. Utilisez Mutex pour contrôler l'accès aux sections critiques.

package main

import (
    "fmt"
    "sync"
)

type BankAccount struct {
    balance int
    sync.RWMutex
}

func (b *BankAccount) Deposit(amount int) {
    b.Lock()
    defer b.Unlock()
    b.balance += amount
}

func (b *BankAccount) Withdraw(amount int) {
    b.Lock()
    defer b.Unlock()
    b.balance -= amount
}

func (b *BankAccount) Balance() int {
    b.RLock()
    defer b.RUnlock()
    return b.balance
}

func main() {
    var wg sync.WaitGroup
    bankAccount := BankAccount{balance: 100}

    for i := 0; i < 500; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            bankAccount.Deposit(10)
        }()
    }

    for i := 0; i < 500; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            bankAccount.Withdraw(10)
        }()
    }

    fmt.Println(bankAccount.Balance())
    wg.Wait()
}

sync.RWMutex : verrouillage en lecture-écriture🎜🎜Le verrouillage en lecture-écriture permet à plusieurs goroutines de lire des données en même temps, mais ne permet qu'à une seule goroutine d'écrire des données en même temps. Ceci est très utile pour les scénarios nécessitant une lecture et une écriture fréquentes de données partagées. 🎜rrreee

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!