golang中锁的使用

Go中锁分为两种：

• 互斥锁
• 读写锁

1、互斥锁

并发程序对公共资源访问的限制最常见的就是使用互斥锁的方式。在Go中，sync.Mutex 提供了互斥锁的实现。

package main

import (
	"fmt"
	"sync"
)

var wg sync.WaitGroup
var l sync.Mutex

func main() {
	var counter int
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() {
			l.Lock()
			counter++
			l.Unlock()

			wg.Done()
		}()
	}
	wg.Wait()
	fmt.Println("counter: ", counter)
}

当执行了 mutex.Lock() 操作后，如果有另外一个 goroutine
又执行了上锁操作，那么该操作被被阻塞，直到该互斥锁恢复到解锁状态。

2、读写锁

顾名思义，读写锁是对读写操作进行加锁。需要注意的是多个读操作之间不存在互斥关系，这样提高了对共享资源的访问效率。

Go中读写锁由 sync.RWMutex 提供，主要包括：

• func (rw *RWMutex) Lock()

• func (rw *RWMutex) RLock()

• func (rw *RWMutex) RLocker() Locker

• func (rw *RWMutex) RUnlock()

• func (rw *RWMutex) Unlock()

其中 Lock() 即“写锁定”，调用了“写锁定”后，不能有其他goroutine进行读或者写操作。 Unlock()
即“写解锁”，调用了“写解锁”后会唤醒所有因为要进行“读锁定（即:RLock()）” 而被阻塞的 goroutine。

RLock()为“读锁定”，调用“读锁定”后，不能有其他goroutine进行写操作，但是可以进行读操作。RUnlock()
为“读解锁”，调用“读解锁”后，会唤醒一个因为要进行“写锁定”而被阻塞的goroutine。

package main

import (
	"fmt"
	"sync"
	"time"
)

func main() {
	var mutex sync.RWMutex
	arr := []int{1, 2, 3}
	go func() {
		fmt.Println("Try to lock writing operation.")
		mutex.Lock()
		fmt.Println("Writing operation is locked.")

		arr = append(arr, 4)

		fmt.Println("Try to unlock writing operation.")
		mutex.Unlock()
		fmt.Println("Writing operation is unlocked.")
	}()

	go func() {
		fmt.Println("Try to lock reading operation.")
		mutex.RLock()
		fmt.Println("The reading operation is locked.")

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

		fmt.Println("Try to unlock reading operation.")
		mutex.RUnlock()
		fmt.Println("The reading operation is unlocked.")
	}()

	time.Sleep(time.Second * 2)
	return
}

参考资料：
https://studygolang.com/articles/11703