浅谈Golang数据竞态

package main

import (
	"fmt"
	"testing"
	"time"
)

func Test(t *testing.T) {
  fmt.Print("getNum(): ")
	for i := 0; i 

func getNumByWaitGroup() int {
	var num int
	var wg sync.WaitGroup
	wg.Add(1) // 表示有一个任务需要等待，等待任务数+1
	go func() {
		num = 53
		wg.Done() // 完成一个处于等待队列的任务，等待任务-1

		// Done decrements the WaitGroup counter by one.
		// func (wg *WaitGroup) Done() {
		//	wg.Add(-1)
		//}

	}()
	wg.Wait() // 阻塞等待，直到等待队列的任务数为0
	return num
}

func getNumByChannel() int {
	var num int
	ch := make(chan struct{}) // 创建一个类型为结构体的channel，并初始化为空
	go func() {
		num = 53
		ch 

func getNumByChan() 

// 首先，创建一个结构体，其中包含我们想要返回的值以及一个互斥实例
type NumLock struct {
	val int
	m   sync.Mutex
}

func (num *NumLock) Get() int {
	// The `Lock` method of the mutex blocks if it is already locked
	// if not, then it blocks other calls until the `Unlock` method is called
	// Lock方法
	// 调用结构体对象的Lock方法将会锁定该对象中的变量；如果没有，将会阻塞其他调用，直到该互斥对象的Unlock方法被调用

	num.m.Lock()
	// 直到该方法返回，该实例对象才会被解锁
	defer num.m.Unlock()
	// 返回安全类型的实例对象中的值
	return num.val
}

func (num *NumLock) Set(val int) {
	// 类似于上面的getNum方法，锁定num对象直到写入“num.val”的值完成
	num.m.Lock()
	defer num.m.Unlock()
	num.val = val
}

func getNumByLock() int {
	// 创建一个`NumLock`的示例
	num := &NumLock{}
	// 使用“Set”和“Get”来代替常规的复制修改和读取值，这样就可以确保只有在写操作完成时我们才能进行阅读，反之亦然
	go func() {
		num.Set(53)
	}()
	time.Sleep(500)
	return num.Get()
}

package main

import (
	"fmt"
	"strconv"
	"sync"
	"testing"
	"time"
)

func Test(t *testing.T) {
	fmt.Print("getNum(): ")
	for i := 0; i  0; i-- {
			num.Set(i)
			ch 

func main() {
	var wg sync.WaitGroup
	wg.Add(5)
	for i := 0; i 

func main() {
	var wg sync.WaitGroup
	wg.Add(5)
	for i := 0; i 

func ParallelWrite(data []byte) chan error {
	res := make(chan error, 2)
	f1, err := os.Create("file1")
	if err != nil {
		res 

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

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

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 

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) 

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 

c := make(chan struct{}) // or buffered channel

go func() { c