golang 中的锁

锁的作用

- 解决并行运算中，共享数据读写的安全性问题。
- 并行执行中，在锁的位置，同时只能有一个程序获得锁，其他程序不能获得锁。
- 锁的出现，使得并行执行的程序在锁的位置串行化执行。
- 多核、分布式运算、并发执行，才会需要锁。

----------------------------------------------------------------------------
1. 同一个协程不能连续多次调用Lock,否则发生死锁
2. 锁资源时尽量缩小资源的范围，以免引起其它协程超长时间等待
3. mutex传递给外部的时候需要传指针，不然就是实例的拷贝，会引起锁失败
4. 善用defer确保在函数内释放了锁
5. 使用-race在运行时检测数据竞争问题，go test -race ....，go build -race ....
6. 善用静态工具检查锁的使用问题
7. 使用go-deadlock检测死锁，和指定锁超时的等待问题(自己百度工具用法)
8. 能用channel的场景别使用成了lock

sync.Mutex 互斥锁

互斥锁是传统的并发程序对共享资源进行访问控制的主要手段,当执行了 `mutex.Lock()` 操作后，
如果有另外一个 goroutine 又执行了上锁操作，那么该操作被被阻塞，直到该互斥锁恢复到解锁状态。

package main
  import (
  	"sync"
  	"time"
  )
  func main() {
  	var lock sync.Mutex             //定义互斥锁
  	go func() {
  		lock.Lock()                 //获取锁
  		time.Sleep(5 * time.Second) //业务逻辑操作
  		defer lock.Unlock()         //释放锁
  	}()
  }

sync.RWMutex 读写锁

func (*RWMutex) Lock    //将rw锁定为写入状态，禁止其他线程读取或者写入。
func (*RWMutex) Unlock  //解除rw的写入锁状态，如果之前未加写入锁会导致运行时错误。
 
func (*RWMutex) RLock   //将rw锁定为读取状态，禁止其他线程写入，但不禁止读取。
func (*RWMutex) RUnlock //解除rw的读取锁状态，如果之前未加读取锁会导致运行时错误。

1.Lock() 即“写锁定”，调用了“写锁定”后，不能有其他goroutine进行读或者写操作。 

2.Unlock() 即“写解锁”，调用了“写解锁”后会唤醒所有因为要进行“读锁定（即:RLock()）” 
而被阻塞的 goroutine。

3.RLock()为“读锁定”，调用“读锁定”后，不能有其他goroutine进行写操作，但是可以进行读操作。

4.RUnlock() 为“读解锁”，调用“读解锁”后，会唤醒一个因为要进行“写锁定”而被阻塞的goroutine。

package main
import (
	"fmt"
	"sync"
	"time"
)
func main() {
	var mutex sync.RWMutex
	my_arr := []int{10010, 10000, 10086}
	go func() {
		fmt.Println("添加写锁中")
		mutex.Lock()
		fmt.Println("写锁添加完成")

		my_arr = append(my_arr, 12345)

		fmt.Println("尝试解锁写锁")
		mutex.Unlock()
		fmt.Println("解锁写锁成功")
	}()
	go func() {
		fmt.Println("添加读锁中")
		mutex.RLock()
		fmt.Println("读锁添加完成")

		fmt.Println("The len of arr is : ", len(my_arr))

		fmt.Println("解锁读锁中")
		mutex.RUnlock()
		fmt.Println("读锁解锁完成")
	}()
	time.Sleep(time.Second * 5)
	return
}

注意事项:

• sync.Mutex 的锁是不可以嵌套使用的。
• sync.RWMutex 的 mu.Lock() 是不可以嵌套的。
• sync.RWMutex 的 mu.Lock() 中不可以嵌套 mu.RLock()。