思考源于这个问题: golang 中并发读写同一个变量会出现部分错乱吗?
要记得golang中变量的赋值不是并发安全的
什么是并发安全
我理解的并发安全就是当并发和不并发的情况下执行结果是一致的.
比如 count++, ok = !ok, 在非并发下很好理解, 而在并发情况下却容易出现预期之外的结果, 这样的代码就是非并发安全的.
举个例子:
count++ 其实是分成两步执行的. 当分成了两步执行, 那么其他协程就可以趁着这个时间间隙作怪.
如一下 ab两个协程同时 count++
count:= 1
a > 读取count : 1
b > 读取count : 1
a > 计算count+1 : 2
b > 计算count+1 : 2
a > 赋值count : 2
b > 赋值count : 2
这就会发生明明ab协程计算了两次, 可结果还是2.
赋值一个简单的count都会出现偏差, 那么赋值一个更为复杂的结构体会不会有问题呢?
例如以下代码, 会进入x.A != x.B判断分支(概率低 但总会发生). 如果还有其他协程再去读x变量, 则会引发逻辑错误.
func TestX(t *testing.T) {
x := struct {
A int
B int
}{}
var wg sync.WaitGroup
for i := 0; i < 1000000; i++ {
wg.Add(2)
go func(i int) {
defer wg.Done()
x = struct {
A int
B int
}{
A: i,
B: i,
}
}(i)
go func() {
defer wg.Done()
if x.A != x.B {
t.Fatalf("A != B, A: %d, B: %d", x.A, x.B)
}
}()
}
wg.Wait()
t.Log(x)
}
可以想到,
在结构体中有多个字段, a协程赋值了一些字段(A字段), b协程赋值了一些字段(B字段), 此时的整个结构体既不是a协程想要的数据, 也不是b协程想要的数据.
如何解决这个问题呢: 使用atomic.Value
func TestY(t *testing.T) {
v := atomic.Value{}
for i := 0; i < 300000; i++ {
go func() {
y := strconv.FormatInt(int64(i), 10)
v.Store(struct {
X string
Y string
}{
X: y,
Y: y,
})
x := v.Load().(struct {
X string
Y string
})
if x.Y != x.X {
t.Log("-----", x)
}
}()
}
time.Sleep(1 * time.Second)
t.Log(v.Load())
}
或者使用指针
func TestOK(t *testing.T) {
x := &struct {
A int
B int
}{}
var wg sync.WaitGroup
for i := 0; i < 1000000; i++ {
wg.Add(2)
go func(i int) {
defer wg.Done()
x = &struct {
A int
B int
}{
A: i,
B: i,
}
}(i)
go func() {
defer wg.Done()
if x.A != x.B {
t.Fatalf("A != B, A: %d, B: %d", x.A, x.B)
}
}()
}
wg.Wait()
t.Log(x)
}
如何写好并发代码
小心，谨慎，多测试。
最终我们仅有的方法是谨慎地思考多线程代码。除了谨慎的思考就是更谨慎地思考。
---- 摘自 《七周七并发模型》
除了通过加锁, 或使用原子操作来保证并发安全。另外最好方式是: 换个写法，如使用channel 或 函数式编程等，来尽量避免在多个协程中共享变量。
