并发访问 slice 如何做到优雅和安全?

抛出问题

由于 slice/map 是引用类型,golang函数是传值调用,所用参数副本依然是原来的 slice, 并发访问同一个资源会导致竟态条件。

看下面这段代码:

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
package main

import (
"fmt"
"sync"
)

func main() {
var (
slc = []int{}
n = 10000
wg sync.WaitGroup
)

wg.Add(n)
for i := 0; i < n; i++ {
go func() {
slc = append(slc, i)
wg.Done()
}()
}
wg.Wait()

fmt.Println("len:", len(slc))
fmt.Println("done")
}

// Output:
len: 8586
done

真实的输出并没有达到我们的预期,len(slice) < n。 问题出在哪?我们都知道slice是对数组一个连续片段的引用,当slice长度增加的时候,可能底层的数组会被换掉。当出在换底层数组之前,切片同时被多个goroutine拿到,并执行append操作。那么很多goroutine的append结果会被覆盖,导致n个gouroutine append后,长度小于n。

那么如何解决这个问题呢?
map 在 go 1.9 以后官方就给出了 sync.map 的解决方案,但是如果要并发访问 slice 就要自己好好设计一下了。下面提供两种方式,帮助你解决这个问题。

方案 1: 加锁 🔐

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
func main() {
slc := make([]int, 0, 1000)
var wg sync.WaitGroup
var lock sync.Mutex

for i := 0; i < 1000; i++ {
wg.Add(1)
go func(a int) {
defer wg.Done()
// 加🔐
lock.Lock()
defer lock.Unlock()
slc = append(slc, a)
}(i)
wg.Wait()

}

fmt.Println(len(slc))
}

优点是比较简单,适合对性能要求不高的场景。

方案 2: 使用 channel 串行化操作

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
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
type ServiceData struct {
ch chan int // 用来 同步的channel
data []int // 存储数据的slice
}

func (s *ServiceData) Schedule() {
// 从 channel 接收数据
for i := range s.ch {
s.data = append(s.data, i)
}
}

func (s *ServiceData) Close() {
// 最后关闭 channel
close(s.ch)
}

func (s *ServiceData) AddData(v int) {
s.ch <- v // 发送数据到 channel
}

func NewScheduleJob(size int, done func()) *ServiceData {
s := &ServiceData{
ch: make(chan int, size),
data: make([]int, 0),
}

go func() {
// 并发地 append 数据到 slice
s.Schedule()
done()
}()

return s
}

func main() {
var (
wg sync.WaitGroup
n = 1000
)
c := make(chan struct{})

// new 了这个 job 后,该 job 就开始准备从 channel 接收数据了
s := NewScheduleJob(n, func() { c <- struct{}{} })

wg.Add(n)
for i := 0; i < n; i++ {
go func(v int) {
defer wg.Done()
s.AddData(v)

}(i)
}

wg.Wait()
s.Close()
<-c

fmt.Println(len(s.data))
}

实现相对复杂,优点是性能很好,利用了channel的优势

以上代码都有比较详细的注释,就不展开讲了。


-------------The End-------------

本文标题:并发访问 slice 如何做到优雅和安全?

文章作者:cloud sjhan

发布时间:2020年04月22日 - 11:04

最后更新:2020年04月22日 - 12:04

原始链接:https://cloudsjhan.github.io/2020/04/22/并发访问-slice-如何做到优雅和安全?/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

坚持原创技术分享,您的支持将鼓励我继续创作!
0%
;