golang函数中的锁是如何实现的？

Go 语言中的锁实现同步并发代码，防止数据竞争：mutex：互斥锁，保证同一时间只有一个 goroutine 获取锁，用于临界区控制。rwmutex：读写锁，允许多个 goroutine 同时读取数据，但仅一个 goroutine 同时写入数据，适用于需要频繁读写共享数据的场景。

Go 函数中的锁是如何实现的？

在 Go 中，锁主要用于同步并发代码，防止并发访问引起的数据竞争。Go 语言提供了多种类型的锁，每种类型具有不同的特性和使用场景。

sync.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：读写锁

读写锁允许多个 goroutine 同时读取数据，但仅允许一个 goroutine 同时写入数据。这对于需要频繁读写共享数据的场景非常有用。

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()
}

以上就是golang函数中的锁是如何实现的？的详细内容，更多请关注编程网其它相关文章！