Golang 之 锁（mutex）

RWMutex的使用主要事项
1、读锁的时候无需等待读锁的结束
2、读锁的时候要等待写锁的结束
3、写锁的时候要等待读锁的结束
4、写锁的时候要等待写锁的结束

sync互斥锁

　　sync互斥锁有两个常用的方法，Lock()加锁，Unlock()解锁。使用Lock加锁后，不能再进行加锁，只有当对其进行Unlock解锁之后，才能对其加锁。这个很好理解。

• 如果对一个未加锁的资源进行解锁，会引发panic异常。
• 可以在一个goroutine中对一个资源加锁，而在另外一个goroutine中对该资源进行解锁。
• 不要在持有锁的时候做 IO 操作。尽量只通过持有锁来保护 IO 操作需要的资源而不是 IO 操作本身：

func doSomething() {
    m.Lock()
    item := ...
    http.Get()  // 各种耗时的 IO 操作
    m.Unlock()
}

// 改为
func doSomething() {
    m.Lock()
    item := ...
    m.Unlock()

    http.Get()
}

• 善用 defer 来确保在函数内正确释放了锁

  // 尤其是在那些内部有好几个通过 if err != nil 判断来提前返回的函数中，通过 defer 可以确保不会遗漏释放锁操作，避免出现死锁问题，以及避免函数内非预期的 panic 导致死锁的问题
  
  func doSomething() {
      m.Lock()
      defer m.Unlock()
  
      err := ...
      if err != nil {
          return
      }
  
      err = ...
      if err != nil {
          return
      }
  
      ...
      return
  }

package main
import (
    "fmt"
    "sync"
)
func main() {
    var wg sync.WaitGroup
    var mutex sync.Mutex
    wg.Add(2)
    var sum int = 0
    go func() {
        for i := 0; i < 1000; i++ {
            mutex.Lock() //上锁
            sum++
            mutex.Unlock()//解锁
        }
        wg.Done()
    }()
    go func() {
        for i := 0; i < 1000; i++ {
            mutex.Lock() //加锁
            sum++
            mutex.Unlock() //解锁
        }
        wg.Done()
    }()
 
    wg.Wait()
    fmt.Println(sum)
}

sync读写互斥锁（多读单写锁）

　　允许对同一资源进行同时读，但是不能进行同时写，也不能进行一边读，一边写。

　　如果一个资源被加了写锁，那么就不能再给他加其他锁，包括写锁，只能等写锁解开后，才能继续加其他锁。如果一个资源被加了读锁，那么，仍然可以给该资源加读锁，但是不能加写锁，必须等读锁释放后，才能加写锁。

　　sync.RWMutex有四个常用的方法：

　　　　Lock()加写锁  、 Unlock()取消写锁 、 RLock()加读锁 、 RUnlock()释放读锁

package main
 
import (
    "fmt"
    "sync"
    "time"
)
 
var rwMutex sync.RWMutex //定义一个读写互斥锁
 
//注意传递的组等待是指针形式
func WriteData(wg *sync.WaitGroup, id int) {
    rwMutex.Lock() //加 写锁
    fmt.Println("增加第", id, "个写锁")
    for i := 0; i < 5; i++ {
        fmt.Println("进行写操作")
        time.Sleep(time.Second)
    }
    fmt.Println("释放第", id, "个写锁")
    rwMutex.Unlock() //释放 写锁
    wg.Done()
}
 
func ReadData(wg *sync.WaitGroup, id int) {
    rwMutex.RLock() //加 读锁
    fmt.Println("增加第", id, "个读锁")
    for i := 0; i < 5; i++ {
        fmt.Println("进行读操作")
        time.Sleep(time.Second)
    }
    fmt.Println("释放第", id, "个读锁")
    rwMutex.RUnlock() //释放 读锁
    wg.Done()
}
 
func main() {
    var wg sync.WaitGroup
    for i := 1; i < 3; i++ {
        wg.Add(1)
        go WriteData(&wg, i)
    }
    for i := 1; i < 4; i++ {
        wg.Add(1)
        go ReadData(&wg, i)
    }
 
    wg.Wait()
    fmt.Println("主程序执行完毕")
}

sync.once初始化

　　sync.Once的作用就是多次调用，但只执行一次，Once只有一个方法->Once.Do(func)，向Do中传入一个函数，在第一次执行Once.Do()的时候，才执行传入的func，以后在执行Once.Do()，就不会再执行传入的func。

package main
 
import (
    "fmt"
    "sync"
)
 
func demo() {
    fmt.Println("运行demo函数")
}
 
func main() {
    var wg sync.WaitGroup
    var once sync.Once
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            once.Do(demo)
            //注意不要写成once.Do(demo()),这样写是把demo()的运行结果传入Do
            wg.Done()
        }()
    }
    wg.Wait()
    fmt.Println("主程序结束")
}
//这样就不会执行多次demo()，而只输出一次“运行demo函数”