数据竞争（案例）

示例一

func main() {
    var wg sync.WaitGroup
    wg.Add(5)
    for i := 0; i < 5; i++ {
        go func() {
            fmt.Println(i) // Not the 'i' you are looking for.
            wg.Done()
        }()
    }
    wg.Wait()
}

循环内的i被多个goroutine同时读取，代码执行结果有可能是44455或55555而不是 01234；改进办法

func main() {
    var wg sync.WaitGroup
    wg.Add(5)
    for i := 0; i < 5; i++ {
        go func(j int) {
            fmt.Println(j) // Good. Read local copy of the loop counter.
            wg.Done()
        }(i)
    }
    wg.Wait()
}

示例二

随意共享变量

func ParallelWrite(data []byte) chan error {
    res := make(chan error, 2)
    f1, err := os.Create("file1")
    if err != nil {
        res <- err
    } else {
        go func() {
            // This err is shared with the main goroutine,
            // so the write races with the write below.
            _, err = f1.Write(data)
            res <- err
            f1.Close()
        }()
    }
    f2, err := os.Create("file2") // The second conflicting write to err.
    if err != nil {
        res <- err
    } else {
        go func() {
            _, err = f2.Write(data)
            res <- err
            f2.Close()
        }()
    }
    return res
}

上述代码：goroutine内共享了外部作用域的变量，导致数据读取出错

改进方案(注意 := 的使用)

_, err := f1.Write(data)
...
_, err := f2.Write(data)

示例三

未保护的全局变量，map的并发读取

var service map[string]net.Addr
func RegisterService(name string, addr net.Addr) {
    service[name] = addr
}
func LookupService(name string) net.Addr {
    return service[name]
}

上述代码中的方法，如使用goroutine 调用则会发生数据争用，改进方案

var (
    service   map[string]net.Addr
    serviceMu sync.Mutex
)
 
func RegisterService(name string, addr net.Addr) {
    serviceMu.Lock()
    defer serviceMu.Unlock()
    service[name] = addr
}
 
func LookupService(name string) net.Addr {
    serviceMu.Lock()
    defer serviceMu.Unlock()
    return service[name]
}

示例四

原生数据变量的保护

type Watchdog struct{ last int64 }
func (w *Watchdog) KeepAlive() {
    w.last = time.Now().UnixNano() // First conflicting access.
}
func (w *Watchdog) Start() {
    go func() {
        for {
            time.Sleep(time.Second)
            // Second conflicting access.
            if w.last < time.Now().Add(-10*time.Second).UnixNano() {
                fmt.Println("No keepalives for 10 seconds. Dying.")
                os.Exit(1)
            }
        }
    }()
}

上述 的 Watchdog 结构体中变量的读取与修改会产生数据竞争，改进方案如下（使用sync/atomic 包）

type Watchdog struct{ last int64 }
func (w *Watchdog) KeepAlive() {
    atomic.StoreInt64(&w.last, time.Now().UnixNano())
}
func (w *Watchdog) Start() {
    go func() {
        for {
            time.Sleep(time.Second)
            if atomic.LoadInt64(&w.last) < time.Now().Add(-10*time.Second).UnixNano() {
                fmt.Println("No keepalives for 10 seconds. Dying.")
                os.Exit(1)
            }
        }
    }()
}

示例五

c := make(chan struct{})
// The race detector cannot derive the happens before relation
// for the following send and close operations. These two operations
// are unsynchronized and happen concurrently.
go func() { c <- struct{}{} }()
close(c)

如上，主程与goroutine未同步，主程结束后goroutine也被销毁，改进方案：

c := make(chan struct{}) // or buffered channel
go func() { c <- struct{}{} }()
<-c
close(c)