Check data race

“Data race” is a common but notorious issue in concurrency programs. sometimes it is difficult to debug and reproduce, especially in some big system, so this will make people very frustrated. Thankfully, the Go toolchain provides a race detector (now only works on amd64 platform.) which can help us quickly spot and fix this kind of issue, and this can save our time even lives!

Take the following classic “data race” program as an example: 

  1. package main
  3. import (
  4.         "fmt"
  5.         "sync"
  6. )
  8. var global int
  9. var wg sync.WaitGroup
  11. func count() {
  12.         defer wg.Done()
  13.         for i := 0; i < 10000; i++{
  14.                 global++
  15.         }
  16. }
  18. func main() {
  19.         wg.Add(2)
  20.         go count()
  21.         go count()
  22.         wg.Wait()
  23.         fmt.Println(global)
  24. }

Two tasks increase global variable simultaneously, so the final value of global is non-deterministic. Using race detector to check it: 

  1. # go run -race race.go
  2. ==================
  3. WARNING: DATA RACE
  4. Read by goroutine 7:
  5.   main.count()
  6.       /root/gocode/src/race.go:14 +0x6d
  8. Previous write by goroutine 6:
  9.   main.count()
  10.       /root/gocode/src/race.go:14 +0x89
  12. Goroutine 7 (running) created at:
  13.   main.main()
  14.       /root/gocode/src/race.go:21 +0x6d
  16. Goroutine 6 (running) created at:
  17.   main.main()
  18.       /root/gocode/src/race.go:20 +0x55
  19. ==================
  20. 19444
  21. Found 1 data race(s)
  22. exit status 66

Cool! the race detector finds the issue precisely, and it also provides the detailed tips of how to modifying it. Adding the lock of writing the global variable: 

  1. package main
  3. import (
  4.     "fmt"
  5.     "sync"
  6. )
  8. var global int
  9. var wg sync.WaitGroup
  10. var w sync.Mutex
  12. func count() {
  13.     defer wg.Done()
  14.     for i := 0; i < 10000; i++{
  15.         w.Lock()
  16.         global++
  17.         w.Unlock()
  18.     }
  19. }
  21. func main() {
  22.     wg.Add(2)
  23.     go count()
  24.     go count()
  25.     wg.Wait()
  26.     fmt.Println(global)
  27. }

This time, race detector is calm: 

  1. # go run -race non_race.go
  2. 20000

Please be accustomed to use this powerful tool frequently, you will appreciate it, I promise!

Reference:
Introducing the Go Race Detector.