如果全局變量只讀取 那自然是不需要加鎖的

如果全局變量多進程讀，多進程寫，那自然是需要加讀寫鎖的

但是如果全局變量只有一個進程寫，其他進程讀呢？ 如果采用COW的方式，寫進程只是通過單次賦值的方式來更新變量，是否就可以不加鎖了呢？

就第三種情況而言：

當然我們通過 go build -race 或者 go run -race 就會出現(xiàn)

WARNING: DATA RACE。 但是出現(xiàn) data race 就證明一定有問題么？

其實核心點在于這個賦值是否是原子的。也就是說是否存在 p1 = p2 的寫入時，指針被臨時替換為p3，并在此時goroutine切出的情況?？梢韵氲降囊环N情況是64字節(jié)的指針需要兩次mv才能完成全部變量的賦值。那么就有可能在兩次mv中間切出，進而出現(xiàn)p3的情況。

之前在stackoverflow 上有個討論

https://stackoverflow.com/questions/21447463/is-assigning-a-pointer-atomic-in-go

其中高votes的回答是說：

在go中，唯一保證原子性的操作是在 sync.atomic, 所以如果你想確保原子性，可以使用sync.Mutex 或者 sync.atomic 中的原子函數(shù)。 但是我不建議 sync.atomic中函數(shù)， 因為你不得不在任何使用指針的地方使用他們，這是非常難做到正確使用的。

用mutex 是好的go style - 你可以很方便的定義一個函數(shù)返回指針。 比如

import "sync"
var secretPointer *int
var pointerLock sync.Mutex
func CurrentPointer() *int {
    pointerLock.Lock()
    defer pointerLock.Unlock()
    return secretPointer
}
func SetPointer(p *int) {
    pointerLock.Lock()
    secretPointer = p
    pointerLock.Unlock()
}

所以一個ok的go style 應該是使用 sync.Mutex 的。

golang doc也是這么說的。

type T struct {
 msg string
}
var g *T
func setup() {
 t := new(T)
 t.msg = "hello, world"
 g = t
}
func main() {
 go setup()
 for g == nil {
 }
 print(g.msg)
}

Even if main observes g != nil and exits its loop, there is no guarantee that it will observe the initialized value for g.msg.

In all these examples, the solution is the same: use explicit synchronization.

但是當我們用go tool asm看時， 確實只有一個指令 MOVQ。

所以只能說

因為規(guī)范沒有指定，所以你應該假設它不是原子的。即使它現(xiàn)在是原子的，它也有可能在不違反規(guī)范的情況下改變。

總之我們不應該做賦值原子的假設，而應該按照規(guī)范，使用sync.Mutex 來做。

補充：Golang對全局變量加鎖同步解決資源訪問共享問題——使用Go協(xié)程來同時并發(fā)計算多個數(shù)字（1-200）的階乘

使用互斥鎖解決資源共享問題

使用Go協(xié)程來同時并發(fā)計算多個數(shù)字（1-200）的階乘，然后存儲在數(shù)組當中

package main 
import (
 "fmt"
 "time"
)
 
var(
 myMap = make(map[int]int, 10)
)
 
func test(n int){
 res:=1
 for i:=1; i=n; i++{
  res*=i
 }
 myMap[n]=res
}
 
func main(){
 for i:=1; i=200; i++{
  go test(i)
 }
 
 time.Sleep(time.Second*10) 
 for i,v:=range myMap{
  fmt.Printf("myMap[%d]=%d\n", i, v)
 }
}

代碼如下，運行結(jié)果如下：但是我們發(fā)現(xiàn)其并沒有正常計算出各個數(shù)字的階乘來

原因是我們沒有對全局變量myMap加鎖，導致了資源搶奪的問題，因此我們可以對代碼加入互斥鎖

package main 
import (
 "fmt"
 "time"
 "sync"
)
 
var(
 myMap = make(map[int]int, 10)
 //聲明一個全局互斥鎖
 lock sync.Mutex
)
 
func test(n int){
 res:=1
 for i:=1; i=n; i++{
  res+=i //這里我將階乘改成求和，防止數(shù)據(jù)溢出
 }
 //加鎖
 lock.Lock()
 myMap[n]=res
 //解鎖
 lock.Unlock()
}
 
func main(){
 for i:=1; i=200; i++{
  go test(i)
 }
 
 time.Sleep(time.Second*10)
 
 for i,v:=range myMap{
  fmt.Printf("myMap[%d]=%d\n", i, v)
 }
}

對資源加了互斥鎖之后，多個協(xié)程之間的并發(fā)問題就得到了解決

但是上述解決方案不太完美，有其缺陷：

（1）主線程在等待所有goroutine全部完成的時間很難確定

（2）如果主線程休眠時間過長，就會加長等待時間，如果等待時間短了，還可能會有goroutine因為主線程的退出而被銷毀

（3）通過全局變量加鎖同步來實現(xiàn)通訊，也不利于多個協(xié)程對全局變量的讀寫操作

以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。