golang sync

##Goroutine 内存占用

下面是一个创建 goroutine 什么也不干,对内存的占用打印。说明创建 goroutine 的成本非常低。

1
2
3
4
5
6
7
num:1  mem: 0.062MB average:64.000kb 
num:10 mem: 0.000MB average:0.000kb
num:100 mem: 0.000MB average:0.000kb
num:1000 mem: 0.250MB average:0.256kb
num:10000 mem: 1.373MB average:0.141kb
num:100000 mem: 265.852MB average:2.722kb
num:1000000 mem: 2462.125MB average:2.521kb

以下是创建代码:

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

import (
"fmt"
"runtime"
"sync"
)

// goroutine : go 中的每个并发执行单元叫 go routine

// 返回从系统中获取的字节数
func memConsumed() uint64 {
runtime.GC()
var s runtime.MemStats
runtime.ReadMemStats(&s)
return s.Sys //系统字节数
}

// 获取创建指定数量协程
func memChannel(num uint64) {
var c <-chan interface{}

var wg sync.WaitGroup
noop := func() {
wg.Done()
<-c
}
wg.Add(int(num))
before := memConsumed()
for i := num; i > 0; i-- {
go noop()
}
wg.Wait()
after := memConsumed()
fmt.Printf("num:%d mem: %.3fMB average:%.3fkb \n", num, float64(after-before)/1024/1024, float64(after-before)/1024/float64(num))

}

func main() {
memChannel(1)
memChannel(1e1)
memChannel(1e2)
memChannel(1e3)
memChannel(1e4)
memChannel(1e5)
memChannel(1e6) // 百万
}

WaitGroup

用于等待线程结束,Add 为计数器 +n,Done 线程结束方法。 当调用到 n个 Done 后 ,如果计数器小于 0 ,Wait 阻塞结束。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
var wg sync.WaitGroup
var urls = []string{
"http://www.golang.org/",
"http://www.google.com/",
"http://www.somestupidname.com/",
}
for _, url := range urls {
// Increment the WaitGroup counter.
wg.Add(1)
// Launch a goroutine to fetch the URL.
go func(url string) {
// Decrement the counter when the goroutine completes.
defer wg.Done()
// Fetch the URL.
http.Get(url)
}(url)
}
// Wait for all HTTP fetches to complete.
wg.Wait()

Mutex

Mutex 是一个互斥锁。 具有两个方法 Lock 和 Unlock。

Lock 如果加锁,则阻塞到解锁 。

Unlock 如果未加锁会导致运行错误。

RWMutex

读写互斥锁,可以多个读一个写。

Lock /Unlock 同 Mutex

Rlock/RUnlock 锁定为读取,禁止写,允许读。

Once

Do 只能执行一次.

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

func main() {
var once sync.Once
onceBody := func() {
fmt.Println("Only once")
}

done := make(chan bool)

for i := 0; i < 5; i++ {
go func() {
fmt.Println("go run \n")
once.Do(onceBody) // 只会执行一次
done <- true
}()
}

for i := 0; i < 5; i++ {
fmt.Printf("done channel :%v \n", <-done)
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
$ go run once.go
go run

Only once
done channel :true
go run

done channel :true
go run

go run

done channel :true
go run

done channel :true
done channel :true

Cond

条件锁,当满足某些条件才起作用的锁。

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

import (
"fmt"
"sync"
"time"
)

func main() {

var lc = new(sync.Mutex)
var cond = sync.NewCond(lc)

for i := 0; i < 3; i++ {
go func(x int) {
cond.L.Lock()
defer cond.L.Unlock()
cond.Wait()
fmt.Println(x)
}(i)
}

time.Sleep(2 * time.Second)
fmt.Println("1--\n")
cond.Signal()
time.Sleep(2 * time.Second)
fmt.Println("2--\n")
cond.Broadcast()
time.Sleep(2 * time.Second)

}
1
2
3
4
5
6
7
8
$ go run cone.go
1-- # signal

0
2-- # broadcast

1
2

Pool

sync.Pool有两个公开的方法。一个是Get,另一个是Put。前者的功能是从池中获取一个interface{}类型的值,而后者的作用则是把一个interface{}类型的值放置于池中。

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
// 一个[]byte的对象池,每个对象为一个[]byte
var bytePool = sync.Pool{
New: func() interface{} {
b := make([]byte, 1024)
return &b
},
}

func main() {
a := time.Now().Unix()
// 不使用对象池
for i := 0; i < 1000000000; i++{
obj := make([]byte,1024)
_ = obj
}
b := time.Now().Unix()
// 使用对象池
for i := 0; i < 1000000000; i++{
obj := bytePool.Get().(*[]byte)
_ = obj
bytePool.Put(obj)
}
c := time.Now().Unix()
fmt.Println("without pool ", b - a, "s")
fmt.Println("with pool ", c - b, "s")
}

// without pool 34 s
// with pool 24 s
作者

张巍

发布于

2020-01-10

更新于

2022-04-22

许可协议

评论