如何在Go中使用锁？-Golang-PHP中文网

如何在Go中使用锁？

PHPz

发布： 2023-05-11 15:33:06

原创

3062人浏览过

在并发编程中，锁（lock）是用来保护共享资源的一种机制。在go语言中，锁是实现并发的重要工具之一。它可以确保在多个协程中同时访问共享资源时，只有一个协程能够读取或修改这些资源。本文将介绍go语言中锁的使用方法，帮助读者更好地理解并发编程。

互斥锁

互斥锁（Mutual Exclusion Lock）是Go语言中最常用的锁机制。它确保同一时刻只有一个协程可以访问临界区。通俗地说，互斥锁通过将共享资源包裹在锁临界区内，确保同一时间内只有一个协程访问。

在Go语言中使用互斥锁非常简单。我们可以使用sync包中的Mutex类型来创建一个互斥锁：

import "sync"

var mutex = &sync.Mutex{}

登录后复制

之后，在需要保护共享资源的位置中，我们可以使用以下代码获取锁：

mutex.Lock()
defer mutex.Unlock()

登录后复制

值得注意的是，互斥锁不支持重入。如果一个协程已经获取到了这个锁，再次尝试获取锁将会导致死锁。所以，我们通常使用defer语句来在协程结束时自动释放锁。

下面是一个使用互斥锁的例子：

import (
    "fmt"
    "sync"
)

var count = 0
var mutex = &sync.Mutex{}

func increment(wg *sync.WaitGroup) {
    mutex.Lock()
    defer mutex.Unlock()
    count++
    wg.Done()
}

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

登录后复制

在这个例子中，我们使用互斥锁保护一个计数器。1000个协程同时执行increment函数，每次将计数器加1。由于互斥锁的使用，程序可以正确地输出最终的计数器值。

读写锁

在多协程环境中，读写锁（Read-Write Lock）可能优于互斥锁。相比之下，它可以在多个协程同时读取共享资源时保持高效，但是在有写操作时，仍然需要互斥访问。

读写锁由两种类型的锁组成：读锁和写锁。读锁允许多个协程同时访问共享资源，但是写锁保证了同一时间只能有一个协程访问。

在Go语言中，可以使用sync包中的RWMutex类型来创建一个读写锁。

如知AI笔记

如知笔记——支持markdown的在线笔记，支持ai智能写作、AI搜索，支持DeepseekR1满血大模型

查看详情

import "sync"

var rwlock = &sync.RWMutex{}

登录后复制

读锁和写锁的获取方法不同。下面是一些常见的用法：

获取读锁: rwlock.RLock()
释放读锁: rwlock.RUnlock()
获取写锁: rwlock.Lock()
释放写锁: rwlock.Unlock()

下面是一个使用读写锁的例子：

import (
    "fmt"
    "sync"
)

var count = 0
var rwlock = &sync.RWMutex{}

func increment(wg *sync.WaitGroup) {
    rwlock.Lock()
    defer rwlock.Unlock()
    count++
    wg.Done()
}

func read(wg *sync.WaitGroup) {
    rwlock.RLock()
    defer rwlock.RUnlock()
    fmt.Println("Count:", count)
    wg.Done()
}

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

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go read(&wg)
    }
    wg.Wait()
}

登录后复制

在这个例子中，我们同时开启了10个协程向计数器中写入数据，以及5个协程读取计数器数据。通过使用读写锁，程序可以以高效的方式读取共享资源，同时确保写操作的原子性。

原子操作

在Go语言中，也可以使用原子操作来保证同步原语的操作是原子性的。原子操作不需要加锁，因此在某些情况下比锁更高效。

Go语言内置了多个原子操作函数，可以参考官方文档查看。这里介绍两个常用的原子操作函数：atomic.Add和atomic.Load。

atomic.Add: 对一个整数进行原子加操作。
atomic.Load: 原子地读取一个整数的值。

下面是一个例子：

import (
    "fmt"
    "sync/atomic"
    "time"
)

var count int32 = 0

func increment(wg *sync.WaitGroup) {
    defer wg.Done()
    atomic.AddInt32(&count, 1)
}

func printCount() {
    fmt.Println("Count: ", atomic.LoadInt32(&count))
}

func main() {
    var wg sync.WaitGroup

    for i := 0; i < 5; i++ {
        wg.Add(1)
        go increment(&wg)
    }
    wg.Wait()
    printCount()

    time.Sleep(time.Second)

    for i := 0; i < 3; i++ {
        wg.Add(1)
        go increment(&wg)
    }
    wg.Wait()
    printCount()
}

登录后复制

在这个例子中，我们使用atomic.Add函数对计数器进行原子加操作，使用atomic.Load函数原子地读取计数器的值。通过使用原子操作，我们可以避免锁的开销，实现更高效的并发编程。