初识Golang Mutex互斥锁的使用

目录
  • 前言
  • 为什么要使用互斥锁
  • 如何使用互斥锁
    • 使用方式一:直接声明使用
    • 使用方式二:封装在其他结构体中
  • 互斥锁的常见问题

前言

在学习操作系统的时候,我们应该都学习过临界区、互斥锁这些概念,用于在并发环境下保证状态的正确性。比如在秒杀时,100 个用户同时抢 10 个电脑,为了避免少卖或者超卖,就需要使用锁来进行并发控制。在 Go语言 里面互斥锁是 sync.Mutex ,我们本篇文章就来学习下为什么要使用互斥锁、如何使用互斥锁,以及使用时的常见问题。

为什么要使用互斥锁

我们来看一个示例:我们起了 10000 个协程将变量 num 加1,因此肯定会存在并发,如果我们不控制并发,10000 个协程都执行完后,该变量的值很大概率不等于 10000。

那么为什么会出现这个问题呢,原因是 num++ 不是原子操作,它会先读取变量 num 当前值,然后对这个值 加1,再把结果保存到 num 中。例如 10 个 goroutine 同时运行到 num++ 这一行,可能同时读取 num=1000,都加1后再保存, num=1001,这就与想要的结果不符。

package main

import (
 "fmt"
 "sync"
)

func main() {
 num := 0

 var wg sync.WaitGroup
 threadCount := 10000
 wg.Add(threadCount)
  
 for i := 0; i < threadCount; i++ {
  go func() {
   defer wg.Done()
   num++
  }()
 }
  
 wg.Wait() // 等待 10000 个协程都执行完
  fmt.Println(num) // 9388(每次都可能不一样)

}

我们如果使用了互斥锁,可以保证每次进入临界区的只有一个 goroutine,一个 goroutine 执行完后,另一个 goroutine 才能进入临界区执行,最终就实现了并发控制。

并发获取锁示意图

package main

import (
 "fmt"
 "sync"
)

func main() {
 num := 0
 var mutex sync.Mutex  // 互斥锁

 var wg sync.WaitGroup
 threadCount := 10000
 wg.Add(threadCount)
 for i := 0; i < threadCount; i++ {
  go func() {
   defer wg.Done()
   
   mutex.Lock() // 加锁
   num++ // 临界区
   mutex.Unlock() // 解锁
   
  }()
 }

 wg.Wait()
 fmt.Println(num) // 10000

}

如何使用互斥锁

Mutex 保持 Go 一贯的简洁风格,开箱即用,声明一个变量默认是没有加锁的,加锁使用 Lock() 方法,解锁使用 Unlock() 方法。

使用方式一:直接声明使用

这个在上例中已经体现了,直接看上面的例子就好

使用方式二:封装在其他结构体中

我们可以将 Mutex 封装在 struct 中,封装成线程安全的函数供外部调用。比如我们封装了一个线程安全的计数器,调用 Add() 就加一,调用Count() 返回计数器的值。

package main

import (
 "fmt"
 "sync"
)

type Counter struct {
 num   int
 mutex sync.Mutex
}

// 加一操作,涉及到临界区 num,加锁解锁
func (counter *Counter) Add() {
 counter.mutex.Lock()
 defer counter.mutex.Unlock()
 counter.num++
}

// 返回数量,涉及到临界区 num,加锁解锁
func (counter *Counter) Count() int {
 counter.mutex.Lock()
 defer counter.mutex.Unlock()
 return counter.num
}

func main() {
 threadCount := 10000
  
 var counter Counter
 var wg sync.WaitGroup
 
 wg.Add(threadCount)
 for i := 0; i < threadCount; i++ {
  go func() {
   defer wg.Done()
   counter.Add()
  }()
 }

 wg.Wait() // 等待所有 goroutine 都执行完
 fmt.Println(counter.Count()) // 10000

}

在 Go 中,map 结构是不支持并发的,如果并发读写就会 panic

// 运行会 panic,提示 fatal error: concurrent map writes
func main() {
 m := make(map[string]string)
 var wait sync.WaitGroup
 wait.Add(1000)

 for i := 0; i < 1000; i++ {
  item := fmt.Sprintf("%d", i)
  go func() {
   wait.Done()
   m[item] = item
  }()
 }
 wait.Wait()
}

基于 Mutex ,我们可以实现一个线程安全的 map

import (
 "fmt"
 "sync"
)

type ConcurrentMap struct {
 mutex sync.Mutex
 items map[string]interface{}
}

func (c *ConcurrentMap) Add(key string, value interface{}) {
 c.mutex.Lock()
 defer c.mutex.Unlock()
 c.items[key] = value
}

func (c *ConcurrentMap) Remove(key string) {
 c.mutex.Lock()
 defer c.mutex.Unlock()
 delete(c.items, key)
}
func (c *ConcurrentMap) Get(key string) interface{} {
 c.mutex.Lock()
 defer c.mutex.Unlock()
 return c.items[key]
}

func NewConcurrentMap() ConcurrentMap {
 return ConcurrentMap{
  items: make(map[string]interface{}),
 }
}

func main() {
 m := NewConcurrentMap()
 var wait sync.WaitGroup
 wait.Add(1000)

 for i := 0; i < 1000; i++ {
  item := fmt.Sprintf("%d", i)
  go func() {
   wait.Done()
   m.Add(item, item)
  }()
 }
 wait.Wait()
 fmt.Println(m.Get("100")) // 100
}

当然,基于互斥锁 Mutex 实现的线程安全 map 并不是性能最好的,基于读写锁 sync.RWMutex 和 分片 可以实现性能更好的、线程安全的 map,开发中比较常用的并发安全 map 是 orcaman / concurrent-map(https://github.com/orcaman/concurrent-map)。

互斥锁的常见问题

从上面可以看出,Mutex 的使用过程方法比较简单,但还是有几点需要注意:

1.Mutex是可以在 goroutine A 中加锁,在 goroutine B 中解锁的,但是在实际使用中,尽量保证在同一个 goroutine 中加解锁。比如 goroutine A 申请到了锁,在处理临界区资源的时候,goroutine B 把锁释放了,但是 A 以为自己还持有锁,会继续处理临界区资源,就可能会出现问题。

2.Mutex的加锁解锁基本都是成对出现,为了解决忘记解锁,可以使用 defer 语句,在加锁后直接 defer mutex.Unlock();但是如果处理完临界区资源后还有很多耗时操作,为了尽早释放锁,不建议使用 defer,而是在处理完临界区资源后就调用 mutex.Unlock() 尽早释放锁。

// 逻辑复杂,可能会忘记释放锁
func main() {
 var mutex sync.Mutex
 mutex.Lock()

 if *** {
  if *** {
   // 处理临界区资源
   mutex.Unlock()
   return
  }
  // 处理临界区资源
  mutex.Unlock()
  return
 }

 // 处理临界区资源
 mutex.Unlock()
 return
}

// 避免逻辑复杂忘记释放锁,使用 defer语句,成对出现
func main() {
 var mutex sync.Mutex
 mutex.Lock()
 defer mutex.Unlock()

 if *** {
  if *** {
   // 处理临界区资源
   return
  }
  // 处理临界区资源
  return
 }

 // 处理临界区资源
 return
}

3.Mutex 不能复制使用

Mutex 是有状态的,比如我们对一个 Mutex 加锁后,再进行复制操作,会把当前的加锁状态也给复制过去,基于加锁的 Mutex 再加锁肯定不会成功。进行复制操作可能听起来是一个比较低级的错误,但是无意间可能就会犯这种错误。

package main

import (
 "fmt"
 "sync"
)

type Counter struct {
 mutex sync.Mutex
 num   int
}

func SomeFunc(c Counter) {
 c.mutex.Lock()
 defer c.mutex.Unlock()
 c.num--
}

func main() {
 var counter Counter
 counter.mutex.Lock()
 defer counter.mutex.Unlock()

 counter.num++
 // Go都是值传递,这里复制了 counter,此时 counter.mutex 是加锁状态,在 SomeFunc 无法再次加锁,就会一直等待
 SomeFunc(counter)

}

以上就是初识Golang Mutex互斥锁的使用的详细内容,更多关于Golang Mutex互斥锁的资料请关注我们其它相关文章!

(0)

相关推荐

  • Golang Mutex 原理详细解析

    目录 前言 Lock 单协程加锁 加锁被阻塞 Unlock 无协程阻塞下的解锁 解锁并唤醒协程 自旋 什么是自旋 自旋条件 自旋的优势 自旋的问题 Mutex 的模式 Normal 模式 Starving 模式 Woken 状态 前言 互斥锁是在并发程序中对共享资源进行访问控制的主要手段.对此 Go 语言提供了简单易用的 Mutex.Mutex 和 Goroutine 合作紧密,概念容易混淆,一定注意要区分各自的概念. Mutex 是一个结构体,对外提供 Lock()和Unlock()两个方法,

  • GO语言协程互斥锁Mutex和读写锁RWMutex用法实例详解

    sync.Mutex Go中使用sync.Mutex类型实现mutex(排他锁.互斥锁).在源代码的sync/mutex.go文件中,有如下定义: // A Mutex is a mutual exclusion lock. // The zero value for a Mutex is an unlocked mutex. // // A Mutex must not be copied after first use. type Mutex struct { state int32 sem

  • Go语言并发编程之互斥锁Mutex和读写锁RWMutex

    目录 一.互斥锁Mutex 1.Mutex介绍 2.Mutex使用实例 二.读写锁RWMutex 1.RWMutex介绍 2.RWMutex使用实例 在并发编程中,多个Goroutine访问同一块内存资源时可能会出现竞态条件,我们需要在临界区中使用适当的同步操作来以避免竞态条件.Go 语言中提供了很多同步工具,本文将介绍互斥锁Mutex和读写锁RWMutex的使用方法. 一.互斥锁Mutex 1.Mutex介绍 Go 语言的同步工具主要由 sync 包提供,互斥锁 (Mutex) 与读写锁 (R

  • Go并发同步Mutex典型易错使用场景

    目录 Mutex的4种易错使用场景 1.Lock/Unlock 不成对出现 2.Copy 已使用的 Mutex 3.重入 4.死锁 解决策略 Mutex的4种易错使用场景 1.Lock/Unlock 不成对出现 Lock/Unlock 没有成对出现,就可能会出现死锁或者是因为Unlock一个未加锁的Mutex而导致 panic. 忘记Unlock的情形 代码中有太多的 if-else 分支,可能在某个分支中漏写了 Unlock: 在重构的时候把 Unlock 给删除了: Unlock 误写成了

  • Golang Mutex互斥锁深入理解

    目录 引言 Mutex结构 饥饿模式和正常模式 正常模式 饥饿模式 状态的切换 加锁和解锁 加锁 自旋 计算锁的新状态 更新锁状态 解锁 可能遇到的问题 锁拷贝 panic导致没有unlock 引言 Golang的并发编程令人着迷,使用轻量的协程.基于CSP的channel.简单的go func()就可以开始并发编程,在并发编程中,往往离不开锁的概念. 本文介绍了常用的同步原语 sync.Mutex,同时从源码剖析它的结构与实现原理,最后简单介绍了mutex在日常使用中可能遇到的问题,希望大家读

  • 初识Golang Mutex互斥锁的使用

    目录 前言 为什么要使用互斥锁 如何使用互斥锁 使用方式一:直接声明使用 使用方式二:封装在其他结构体中 互斥锁的常见问题 前言 在学习操作系统的时候,我们应该都学习过临界区.互斥锁这些概念,用于在并发环境下保证状态的正确性.比如在秒杀时,100 个用户同时抢 10 个电脑,为了避免少卖或者超卖,就需要使用锁来进行并发控制.在 Go语言 里面互斥锁是 sync.Mutex ,我们本篇文章就来学习下为什么要使用互斥锁.如何使用互斥锁,以及使用时的常见问题. 为什么要使用互斥锁 我们来看一个示例:我

  • Golang Mutex互斥锁源码分析

    目录 前言 Mutex 特性 数据结构 Lock() Unlock() 前言 在上一篇文章中,我们一起学习了如何使用 Go 中的互斥锁 Mutex,那么本篇文章,我们就一起来探究下 Mutex 底层是如何实现的,知其然,更要知其所以然! 说明:本文中的示例,均是基于Go1.17 64位机器 Mutex 特性 Mutex 就是一把互斥锁,可以想象成一个令牌,有且只有这一个令牌,只有持有令牌的 goroutine 才能进入房间(临界区),在房间内执行完任务后,走出房间并把令牌交出来,如果还有其余的 

  • 一文掌握Go语言并发编程必备的Mutex互斥锁

    目录 1. Mutex 互斥锁的基本概念 2. Mutex 互斥锁的基本用法 3. Mutex 互斥锁的底层实现 3.1 等待队列 3.2 锁状态 4. Mutex 互斥锁的注意事项 4.1 不要将 Mutex 作为函数或方法的参数传递 4.2 不要在获取 Mutex 的锁时阻塞太久 4.3 不要重复释放 Mutex 的锁 4.4 不要在锁内部执行阻塞或耗时操作 5. 总结 在并发编程中,我们需要处理多个线程同时对共享资源的访问问题.如果不加控制地同时访问共享资源,就会导致竞争条件(Race C

  • 详解golang RWMutex读写互斥锁源码分析

    针对Golang 1.9的sync.RWMutex进行分析,与Golang 1.10基本一样除了将panic改为了throw之外其他的都一样. RWMutex是读写互斥锁.锁可以由任意数量的读取器或单个写入器来保持. RWMutex的零值是一个解锁的互斥锁. 以下代码均去除race竞态检测代码 源代码位置:sync\rwmutex.go 结构体 type RWMutex struct { w Mutex // 互斥锁 writerSem uint32 // 写锁信号量 readerSem uin

  • GoLang中的互斥锁Mutex和读写锁RWMutex使用教程

    目录 一.竞态条件与临界区和同步工具 (1)竞态条件 (2)临界区 (3)同步工具 二.互斥量 三.使用互斥锁的注意事项 (1)使用互斥锁的注意事项 (2)使用defer语句解锁 (3)sync.Mutex是值类型 四.读写锁与互斥锁的异同 (1)读/写互斥锁 (2)读写锁规则 (3)解锁读写锁 一.竞态条件与临界区和同步工具 (1)竞态条件 一旦数据被多个线程共享,那么就会产生冲突和争用的情况,这种情况被称为竞态条件.这往往会破坏数据的一致性. 同步的用途有两个,一个是避免多线程在同一时刻操作

  • 详解Golang互斥锁内部实现

    go语言提供了一种开箱即用的共享资源的方式,互斥锁(sync.Mutex), sync.Mutex的零值表示一个没有被锁的,可以直接使用的,一个goroutine获得互斥锁后其他的goroutine只能等到这个gorutine释放该互斥锁,在Mutex结构中只公开了两个函数,分别是Lock和Unlock,在使用互斥锁的时候非常简单,本文并不阐述使用. 在使用sync.Mutex的时候千万不要做值拷贝,因为这样可能会导致锁失效.当我们打开我们的IDE时候跳到我们的sync.Mutex 代码中会发现

  • golang并发安全及读写互斥锁的示例分析

    目录 并发安全和锁 互斥锁 读写互斥锁 并发安全和锁 有时候在Go代码中可能会存在多个goroutine同时操作一个资源(临界区),这种情况会发生竞态问题(数据竞态).类比现实生活中的例子有十字路口被各个方向的的汽车竞争:还有火车上的卫生间被车厢里的人竞争. 举个例子: var x int64 var wg sync.WaitGroup func add() { for i := 0; i < 5000; i++ { x = x + 1 } wg.Done() } func main() { w

  • C#多线程中如何运用互斥锁Mutex

    互斥锁(Mutex) 互斥锁是一个互斥的同步对象,意味着同一时间有且仅有一个线程可以获取它. 互斥锁可适用于一个共享资源每次只能被一个线程访问的情况 函数: //创建一个处于未获取状态的互斥锁 Public Mutex(): //如果owned为true,互斥锁的初始状态就是被主线程所获取,否则处于未获取状态 Public Mutex(bool owned): 如果要获取一个互斥锁.应调用互斥锁上的WaitOne()方法,该方法继承于Thread.WaitHandle类 它处于等到状态直至所调用

随机推荐