golang 互斥锁的两种实现

如果一个程序高并发且多线程运行的话，并且数据不加什么处理就有可能会导致数据错乱，为了让结果和我们预期的相符合，往往我们需要做一些处理来保证数据的正确性，下面就来介绍两种方式：
1） 互斥锁(sync.Mutex)
2） chan(通道)
下面先来看一段代码：

package main                   
                               
import (                       
    "fmt"                      
    "sync"                     
)                              
                               
var num int                    
var wg sync.WaitGroup          
                               
func add() {  
    defer wg.Done()            
    num += 1                   
}                              
                               
func main() {                  
    for i := 0; i < 1000; i++ { 
        wg.Add(1)              
        go add()   
            
    }                          
    wg.Wait()                  
    fmt.Println("num:", num)   
}       

这段代码同时有1000个协程去调用add()方法
运行结果：

并发.png
我们发现每次运行结果都不一样（注：如果你是单核CPU将不会出现这个效果），下面先来简单分析下出现这种现象的原因：在多核的系统中，这1000个协程被分配到多个线程里面运行，那么就有可能是并行运行的，比如当前的num=987,后面两个线程同时执行那么结果就是988，但是这不是我们想要的结果，我们想要的是999。那如何解决了，其实小伙伴们应该很容易就会想到，就是我们让num +=1 这个代码同时只让一个线程（这里表现为协程）运行就好了。下面来看改进版的：
** 使用互斥锁**

package main

import (
    "fmt"
    "sync"
)

var num int

var mtx sync.Mutex           
var wg sync.WaitGroup

func add() {
    mtx.Lock()
    defer mtx.Unlock()
    defer wg.Done()
    num += 1
}

func main() {
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go add()
    }
    wg.Wait()
    fmt.Println("num:", num)
}

这段代码在num += 1 这段代码前加了一个互斥锁，那么其他程序想要再次执行num += 1 就会被阻塞起来直到锁被释放，这样就保证了数据不丢失。下面来看下多次运行的结果：

并发.png
我们发现每次运行的结果都是1000，那么问题就解决了。
使用chan

package main

import (
    "fmt"
    "sync"
)

var num int

func add(h chan int, wg *sync.WaitGroup) {
    defer wg.Done()
    h <- 1
    num += 1
    <-h
}

func main() {
    ch := make(chan int, 1)
    wg := &sync.WaitGroup{}

    for i := 0; i < 100; i++ {
        wg.Add(1)
        go add(ch, wg)
    }
    wg.Wait()
    fmt.Println("num:", num)
}

运行结果：

并发-channel.png

我们发现结果也是正确的。

两种方式的对比

1. channel 本质上是一个MessageQueue，主要用于协程之间消息的传递，虽然也可以拿来当互斥锁（但是正常还是应该让mutex做）
2. channel成本更高，channel内部有Mutex，因为它本身属于共享变量，还有一些唤醒协程的一些操作等，比如：因读阻塞的goroutine会被向channel写入数据的goroutine唤醒,结束读取过程；但是Mutex内部就简单得多，仅仅是锁住资源，为了更好的理解这一点，笔者在这里简单的分析下channel和Mutex两种数据结构：
   channel内部是使用一个hchan的一个结构：

//path:src/runtime/chan.go
type hchan struct {
  qcount uint          // 当前队列列中剩余元素个数
  dataqsiz uint        // 环形队列长度，即可以存放的元素个数
  buf unsafe.Pointer   // 环形队列列指针
  elemsize uint16      // 元素的大小
  closed uint32        // 标识关闭状态
  elemtype *_type      // 元素类型
  sendx uint           // 队列下标，指示元素写入时存放到队列列中的位置 
  recvx uint           // 队列下标，指示元素从队列列的该位置读出  
  recvq waitq          // 等待读消息的goroutine队列
  sendq  waitq         // 等待写消息的goroutine队列
  lock mutex           // 互斥锁，chan不允许并发读写
} 

// 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
    sema  uint32
}

从这里我们可以看出channel 里面不只有互斥锁，还有元素类型，大小，goroutine队列等等，比起单个mutex 外多了很多其他的字段，说明channel 的用途不仅仅是作为互斥锁。关于这两种结构的用法笔者后面会更新相关的文章。

总结一点：channel 做互斥锁有点大柴小用的感觉。哈哈，说得不对的地方欢迎小伙伴们指出来