互斥量
# 互斥量
来实现一个自定义atomicInt
package main
import (
"fmt"
"time"
)
type atomicInt int
// increment 实现一个自加1功能
func (a *atomicInt) increment() {
*a++
}
// get 实现一个 获取值 的方法
func (a *atomicInt) get() int {
return int(*a)
}
func main() {
var a atomicInt
a.increment()
go func() {
a.increment()
}()
// 不加时间阻塞,会输出1,不然有一个没有机会去+1
time.Sleep(time.Millisecond)
fmt.Println(a)
}
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
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
使用 race 来查看
➜ go run -race atomic.go
==================
WARNING: DATA RACE
Read at 0x00c0000bc018 by main goroutine:
main.main()
/Users/GolangProjects/src/learngo/atomic/atomic.go:29 +0xb4
Previous write at 0x00c0000bc018 by goroutine 7:
main.(*atomicInt).increment()
/Users/GolangProjects/src/learngo/atomic/atomic.go:12 +0x4c
main.main.func1()
/Users/GolangProjects/src/learngo/atomic/atomic.go:25 +0x30
Goroutine 7 (finished) created at:
main.main()
/Users/GolangProjects/src/learngo/atomic/atomic.go:24 +0x98
==================
2
Found 1 data race(s)
exit status 66
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
29 行读,12 行写,两个冲突了。有可能另外一个人在写的时候另外一个人在读,所以需要加一个锁
package main
import (
"fmt"
"sync"
"time"
)
type atomicInt struct {
value int
lock sync.Mutex
}
// increment 实现一个自加1功能
func (a *atomicInt) increment() {
// 加锁
a.lock.Lock()
defer a.lock.Unlock()
a.value++
}
// get 实现一个 获取值 的方法
func (a *atomicInt) get() int {
a.lock.Lock()
defer a.lock.Unlock()
return a.value
}
func main() {
var a atomicInt
a.increment()
go func() {
a.increment()
}()
time.Sleep(time.Millisecond)
fmt.Println(a.get())
}
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
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
加了锁之后,race
之后就没有警告,这就实现了一个原子化的int
编辑 (opens new window)
上次更新: 2022/04/01, 23:39:38