臭小子のBlog

在 Go 中互斥锁（Mutex）介绍

臭小子

2024 年 12 月 20 日

99 次浏览

暂无评论

2255字数

go语言

互斥锁（Mutex）介绍

互斥锁（Mutex） 是一种用于多线程（并发）编程的同步机制，用于确保在同一时刻只有一个线程能够访问某个资源，防止多个线程同时操作共享数据，避免数据竞态（race condition）和不一致的结果。

在 Go 中，互斥锁是通过 sync.Mutex 类型来实现的。通过使用互斥锁，可以控制对共享资源的访问，使得多个 goroutine 不会在同一时间修改资源，从而确保程序的正确性。

互斥锁的基本操作

sync.Mutex 提供了两个基本方法：

Lock()：获取锁，如果锁已被其他 goroutine 获取，则当前 goroutine 会阻塞，直到锁可用。
Unlock()：释放锁，让其他 goroutine 可以获取该锁。

互斥锁的使用步骤

在访问共享资源之前调用 Lock()，获取互斥锁。
在访问完共享资源后，调用 Unlock()，释放互斥锁。

代码示例：使用互斥锁

以下是一个使用互斥锁控制对共享变量的访问的例子：

package main

import (
    "fmt"
    "sync"
)

// 定义一个计数器类型，包含一个整型变量和一个互斥锁
type Counter struct {
    mu    sync.Mutex // 互斥锁
    value int
}

// 增加计数器的值
func (c *Counter) Increment() {
    // 获取锁，确保当前 goroutine 可以安全地修改 value
    c.mu.Lock()
    defer c.mu.Unlock() // 在函数返回时释放锁
    c.value++
}

// 获取计数器的值
func (c *Counter) GetValue() int {
    // 获取锁，确保当前 goroutine 可以安全地读取 value
    c.mu.Lock()
    defer c.mu.Unlock() // 在函数返回时释放锁
    return c.value
}

func main() {
    var wg sync.WaitGroup

    // 创建 Counter 类型的实例
    counter := Counter{}

    // 启动 10 个 goroutine 来同时增加计数器的值
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            counter.Increment()
        }()
    }

    // 等待所有 goroutine 完成
    wg.Wait()

    // 输出最终计数器的值
    fmt.Println("最终计数器的值:", counter.GetValue())
}

代码解释：

定义 Counter 结构体：
- Counter 结构体包含两个字段：
  - mu：互斥锁，用来控制对 value 字段的并发访问。
  - value：计数器值。
Increment 方法：
- 该方法在增加 value 时会先调用 Lock() 获取锁，然后修改 value，最后调用 Unlock() 释放锁。
- 使用 defer 关键字确保在函数返回时解锁，避免遗漏解锁导致死锁。
GetValue 方法：
- 该方法用来安全地读取 value 的值，同样使用 Lock() 和 Unlock() 来保证并发访问时的数据安全。
在 main 函数中启动多个 goroutine：
- 启动了 10 个 goroutine，每个 goroutine 都会调用 Increment() 方法增加计数器值。
- 使用 sync.WaitGroup 来等待所有 goroutine 执行完毕。
结果：
- 最终输出计数器的值，这个值应该是 10，因为每个 goroutine 都增加了计数器的值。