Go Runtime 介绍

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// 两个协程分别对map进行写操作，map非并发写安全，可能导致竟态问题
func main() {
	c := make(chan bool)
	m := make(map[string]string)
	go func() {
		m["1"] = "a" // First conflicting access.
		c <- true
	}()
	m["2"] = "b" // Second conflicting access.
	<-c
	for k, v := range m {
		fmt.Println(k, v)
	}
}

// 可以通过go test -race 是否存在竟态问题
$ go test -race ./racex/...
==================
WARNING: DATA RACE
Write at 0x00c00009e3c0 by goroutine 8:
  runtime.mapaccess2_faststr()
      /usr/local/go/src/runtime/map_faststr.go:108 +0x43c
  x-learn/runtimex/pprofx/racex.TestMapRace.func1()
      /private/data/x-learn/go-refs/runtimex/pprofx/racex/map_racex_test.go:12 +0x4c
...

// 也可以将竟态错误log到指定文件
$ GORACE="log_path=/tmp/race/report strip_path_prefix=/my/go/sources/" go test -race

// 如果不想某些文件加入竟态检测，直接排除掉
// +build !race

package foo
...

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// bad - typically prints 55555, not 01234
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()
}

// good
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()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

// bad
// ParallelWrite writes data to file1 and file2, returns the errors.
func ParallelWrite(data []byte) chan error {
	res := make(chan error, 2)
	f1, err := os.Create("file1")
	if err != nil {
		res <- err // 可能写入go协程新的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
}

// 竟态检测
$ go test -race ./racex/common_race_err*
PASS
==================
WARNING: DATA RACE
Write at 0x00c0001124f0 by goroutine 8:
  command-line-arguments.ParallelWrite.func1()
      /private/data/x-learn/go-refs/runtimex/pprofx/racex/common_race_err.go:16 +0x80
...

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// bad
// Concurrent reads and writes of the same map are not safe
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]
}

// good
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]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// bad
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)
			}
		}
	}()
}

// ok
// 通过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)
			}
		}
	}()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// 这里存在的问题是，可能向已关闭的通道发生消息
c := make(chan struct{}) // or buffered channel

// 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)

// 也可以检测出来
$ go test -race ./racex/common_race_err_test.go
PASS
==================
WARNING: DATA RACE
Read at 0x00c000090310 by goroutine 9:
  runtime.chansend1()
      /usr/local/go/src/runtime/chan.go:145 +0x2c
  command-line-arguments.TestChanRace.func1()
      /private/data/x-learn/go-refs/runtimex/pprofx/racex/common_race_err_test.go:14 +0x34
...


// good - 根据Go内存模型，消息在chan上的发送一定会在接受之前完成，要同步发送和关闭操作，保证在关闭之前完成发送的接收操作
c := make(chan struct{}) // or buffered channel

go func() { c <- struct{}{} }()
<-c
close(c)