初识Golang Mutex互斥锁的使用

怎么入门Golang编程？需要学习哪些知识点？这是新手们刚接触编程时常见的问题；下面golang学习网就来给大家整理分享一些知识点，希望能够给初学者一些帮助。本篇文章就来介绍《初识Golang Mutex互斥锁的使用》，涉及到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 
<p>我们如果使用了互斥锁，可以保证每次进入临界区的只有一个 <code>goroutine</code>，一个 <code>goroutine</code> 执行完后，另一个 <code>goroutine</code> 才能进入临界区执行，最终就实现了并发控制。</p>
<p style="text-align:center"><img alt="" src="/uploads/20221222/167171310363a4514f131ab.jpg"></p>
<p style="text-align:center">并发获取锁示意图</p>
<pre class="brush:go;">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 
<h2>如何使用互斥锁</h2>
<p><code>Mutex</code> 保持 <code>Go</code> 一贯的简洁风格，开箱即用，声明一个变量默认是没有加锁的，加锁使用 <code>Lock()</code> 方法，解锁使用 <code>Unlock()</code> 方法。</p>
<h3>使用方式一：直接声明使用</h3>
<p>这个在上例中已经体现了，直接看上面的例子就好</p>
<h3>使用方式二：封装在其他结构体中</h3>
<p>我们可以将 <code>Mutex</code> 封装在 <code>struct</code> 中，封装成线程安全的函数供外部调用。比如我们封装了一个线程安全的计数器，调用 <code>Add()</code> 就加一，调用<code>Count()</code> 返回计数器的值。</p>
<pre class="brush:go;">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 
<p>在 <code>Go</code> 中，<code>map</code> 结构是不支持并发的，如果并发读写就会 <code>panic</code></p>
<pre class="brush:go;">// 运行会 panic，提示 fatal error: concurrent map writes
func main() {
 m := make(map[string]string)
 var wait sync.WaitGroup
 wait.Add(1000)

 for i := 0; i 
<p>基于 <code>Mutex</code> ，我们可以实现一个线程安全的 <code>map</code>：</p>
<pre class="brush:go;">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 
<p>当然，基于互斥锁 <code>Mutex</code> 实现的线程安全 <code>map</code> 并不是性能最好的，基于读写锁 <code>sync.RWMutex</code> 和 分片 可以实现性能更好的、线程安全的 <code>map</code>，开发中比较常用的并发安全 <code>map</code> 是 orcaman / concurrent-map（https://github.com/orcaman/concurrent-map）。</p>
<h2>互斥锁的常见问题</h2>
<p>从上面可以看出，<code>Mutex</code> 的使用过程方法比较简单，但还是有几点需要注意：</p>
<p>1.<code>Mutex</code>是可以在 <code>goroutine A</code> 中加锁，在 <code>goroutine B</code> 中解锁的，但是在实际使用中，尽量保证在同一个 goroutine 中加解锁。比如 goroutine A 申请到了锁，在处理临界区资源的时候，goroutine B 把锁释放了，但是 A 以为自己还持有锁，会继续处理临界区资源，就可能会出现问题。</p>
<p>2.<code>Mutex</code>的加锁解锁基本都是成对出现，为了解决忘记解锁，可以使用 <code>defer</code> 语句，在加锁后直接 <code>defer mutex.Unlock()</code>；但是如果处理完临界区资源后还有很多耗时操作，为了尽早释放锁，不建议使用 <code>defer</code>，而是在处理完临界区资源后就调用 <code>mutex.Unlock()</code> 尽早释放锁。</p>
<pre class="brush:go;">// 逻辑复杂，可能会忘记释放锁
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的内容请关注golang学习网公众号！