1. 擴容方案剖析 1.1 擴容問題 在項目初期，我們部署了三個資料庫A、B、C，此時資料庫的規模可以滿足我們的業務需求。為了將數據做到平均分配，我們在Service服務層使用uid%3進行取模分片，從而將數據平均分配到三個資料庫中。 如圖所示： 後期隨著用戶量的增加，用戶產生的數據信息被源源不斷的 ...
今天這篇筆記我們來學習鎖：互斥鎖(Mutex) 和 讀寫鎖(RWMutex)
互斥鎖(Mutex)
首先我們來看一段代碼，沒有加鎖的情況下，兩個goroutine同時修改一個變數，會發生什麼
func main() {
var count int
increment := func() {
count++
fmt.Printf(" Incrementing: %d \n", count)
}
decrement := func() {
count--
fmt.Printf(" Decrementing: %d \n", count)
}
var arithmetic sync.WaitGroup
for i := 0; i <= 5; i++ {
arithmetic.Add(1)
go func() {
defer arithmetic.Done()
increment()
}()
}
for i := 0; i <= 5; i++ {
arithmetic.Add(1)
go func() {
defer arithmetic.Done()
decrement()
}()
}
arithmetic.Wait()
fmt.Println("Arithmetic complete.")
}
上面的代碼定義了一個increment方法和一個decrement方法，他們都操作count變數， 然後各自啟動5個goutinue去調用這兩個方法。 結果如下所示
Decrementing: 1
Incrementing: 2
Incrementing: 1
Decrementing: 0
Decrementing: -1
Decrementing: -1
Incrementing: 0
Decrementing: -2
Decrementing: -3
Incrementing: -2
Incrementing: -1
Incrementing: 0
Arithmetic complete.
我們可以看到，結果是亂的，第一個decrementing 應該是-1，結果這裡輸出了1，第三個incrementing應該是3，結果輸出是1. 這樣的效果肯定不是我們期望的， 當多個goroutine共用一個變數的時候，我們需要加鎖，保證一次只有一個goroutine能夠拿到鎖。如下代碼
func main() {
var count int
var lock sync.Mutex
increment := func() {
lock.Lock()
defer lock.Unlock()
count++
fmt.Printf(" Incrementing: %d \n", count)
}
decrement := func() {
lock.Lock()
defer lock.Unlock()
count--
fmt.Printf(" Decrementing: %d \n", count)
}
var arithmetic sync.WaitGroup
for i := 0; i <= 5; i++ {
arithmetic.Add(1)
go func() {
defer arithmetic.Done()
increment()
}()
}
for i := 0; i <= 5; i++ {
arithmetic.Add(1)
go func() {
defer arithmetic.Done()
decrement()
}()
}
arithmetic.Wait()
fmt.Println("Arithmetic complete.")
}
我們在方法中加了lock.Lock()和defer lock.Unlock()， 運行的效果如下圖
Incrementing: 1
Incrementing: 2
Incrementing: 3
Incrementing: 4
Incrementing: 5
Decrementing: 4
Decrementing: 3
Decrementing: 2
Decrementing: 1
Decrementing: 0
Decrementing: -1
Incrementing: 0
這樣的結果符合我們的預期， incrementing的時候和上一條比加了1， decrementing的時候和上一條比減少了1，代碼改動是有效的，這就是鎖的作用， 加鎖後保證一次只有一個goroutine訪問共用的變數。
讀寫鎖(RWMutex)
什麼是讀寫鎖呢？ 讀寫鎖允許多個只讀操作並行進行，而寫操作會完全互斥。 還是使用上面的例子，假如我有個方法只是想讀取count的value，並不改變它，那麼我們就可以用RWMutex.
我們稍微改變下上面的代碼
func main() {
var count int
var lock sync.RWMutex
increment := func() {
lock.Lock()
defer lock.Unlock()
count++
fmt.Printf(" Incrementing: %d \n", count)
}
decrement := func() {
lock.Lock()
defer lock.Unlock()
count--
fmt.Printf(" Decrementing: %d %d\n", count, time.Now().Nanosecond())
time.Sleep(time.Second)
}
read := func() {
lock.RLock()
defer lock.RUnlock()
fmt.Printf(" reading: %d %d\n", count, time.Now().Nanosecond())
time.Sleep(time.Second)
}
var arithmetic sync.WaitGroup
for i := 0; i <= 5; i++ {
arithmetic.Add(1)
go func() {
defer arithmetic.Done()
increment()
}()
}
for i := 0; i <= 5; i++ {
arithmetic.Add(1)
go func() {
defer arithmetic.Done()
decrement()
}()
}
for i := 0; i <= 10; i++ {
arithmetic.Add(1)
go func() {
defer arithmetic.Done()
read()
}()
}
arithmetic.Wait()
fmt.Println("Arithmetic complete.")
}
兩個改動，將Mutex換成RWMutex， 增加了一個read方法，它只讀取count變數，它加鎖的方法是lock.RLock(), 同時我們故意加了time.Sleep(time.Second)，讓read方法和decrement方法執行的時候，停頓一下。
執行結果如下所示
Incrementing: 1
reading: 1 177230700
reading: 1 177230700
reading: 1 177230700
reading: 1 177230700
reading: 1 177230700
reading: 1 177230700
reading: 1 177230700
reading: 1 177230700
reading: 1 177230700
reading: 1 177230700
reading: 1 177230700
Incrementing: 2
Incrementing: 3
Incrementing: 4
Incrementing: 5
Decrementing: 4 193430000
Decrementing: 3 204475300
Decrementing: 2 213426500
Decrementing: 1 227715200
Decrementing: 0 240186800
Decrementing: -1 255299900
Incrementing: 0
Arithmetic complete.
我們可以看到read方法，幾個gorountine執行的時間幾乎一樣，他們都能拿到讀鎖，不會被阻塞， 而且它拿到了一個準確的當時的value. 而decrement方法，相同的代碼，我們使用的是寫鎖，不同的gorountine會鎖住，他們的執行時間會相差。 這就是讀寫鎖。
拿讀鎖我們還可以用RWMutex.RLocker()來拿到鎖對象sync.Locker。
書中還比較了一個RWMutex和Mutex的性能差異，
當Reader數量比較小(<8)時，RWMutex性能稍差
當Reader數量大於8小於65536的時候， RWMutex比Mutex快一倍
當Reader數量大於131072的時候，RWMutex又比Mutex稍慢
作者說RWMutex要比Mutex稍複雜，所以會有這樣的結果
作者在書中說：通常建議使用RWMutex，而不是Mutex， 因為它在邏輯上更合理。
