中文版Concurrency In Go读书笔记：https://www.kancloud.cn/mutouzhang/go/596804
1. sync.Cond + time.Tick
cond := sync.NewCond(&sync.Mutex{})
go func() {
for range time.Tick(1 * time.Millisecond) {
cond.Broadcast() // 每隔1ms唤醒阻塞在该条件变脸上的goroutine
}
}()
2. 粗粒度锁 vs 细粒度锁(饥饿现象)
package main
import (
"fmt"
"sync"
"time"
)
/*
* 结论: 粗粒度锁(3ns)相比细粒度锁(1ns)，更容易抢占cpu资源，容易导致细粒度锁的goroutine饿死
*/
func main() {
var wg sync.WaitGroup
var sharedLock sync.Mutex
const runtime = 1 * time.Second
// 粗粒度锁goroutine
greedyWorker := func() {
defer wg.Done()
var count int
for begin := time.Now(); time.Since(begin) <= runtime; {
sharedLock.Lock()
time.Sleep(3 * time.Nanosecond)
sharedLock.Unlock()
count++
}
fmt.Printf("Greedy worker was able to execute %v work loops\n", count)
}
// 细粒度锁goroutine
politeWorker := func() {
defer wg.Done()
var count int
for begin := time.Now(); time.Since(begin) <= runtime; {
sharedLock.Lock()
time.Sleep(1 * time.Nanosecond)
sharedLock.Unlock()
sharedLock.Lock()
time.Sleep(1 * time.Nanosecond)
sharedLock.Unlock()
sharedLock.Lock()
time.Sleep(1 * time.Nanosecond)
sharedLock.Unlock()
count++
}
fmt.Printf("Polite worker was able to execute %v work loops.\n", count)
}
wg.Add(2)
go greedyWorker()
go politeWorker()
wg.Wait()
}
3. 内存同步访问：加锁
package main
import (
"fmt"
"math/rand"
"sync"
"time"
)
func main() {
rand.Seed(time.Now().UnixNano())
var memoryAccess sync.Mutex // <1>
var value int
go func() {
time.Sleep(time.Duration(rand.Intn(10)) * time.Millisecond)
memoryAccess.Lock() // <2>
value++
memoryAccess.Unlock() // <3>
}()
time.Sleep(time.Duration(rand.Intn(10)) * time.Millisecond)
memoryAccess.Lock() // <4>
if value == 0 {
fmt.Printf("the value is %v.\n", value)
} else {
fmt.Printf("the value is %v.\n", value)
}
memoryAccess.Unlock() // <5>
}
4. go执行外部命令
exec.Command(命令名，参数).Run() // 例如 ./cmd -deploy=aaa
5. goroutine背后的知识
goroutine不是操作系统线程，也不完全是绿色的线程(由语言运行时管理的线程)，其是更高层次的抽象，被成为协程。
协程是非抢占的并发子程序，也就是说goroutine不能被中断。
Go的独特之处在于goroutine与Go的runtime深度整合，goroutine没有定义自己的暂停或再入点，Go的runtime会监视goroutine的运行时行为，并在goroutine阻塞时自动挂起它们，在goroutine变通畅时恢复它们。
Go的宿主机制实现了所谓的M:N调度器(GPM模型)，这意味着它可以将M个绿色线程映射到N个系统线程，goroutine随后被安排在这些绿色线程上。
Go并发遵循fork-join模型，即fork的子goroutine在任务结束时，最终还是会合并到主goroutine上的。go关键字为Go程序实现了fork，fork的执行者是goroutine。如下图所示:
frok-join模型
下面的go程序代码:
var wg sync.WaitGroup
for _, salutation := range []string{"hello", "greetings", "good day"} {
wg.Add(1)
go func() {
defer wg.Done()
fmt.Println(salutation) // 1
}()
}
wg.Wait()
最终输出结果为: good day三次
- main goroutine不能被中断，只有在运行到wg.Wait时被阻塞，此时其余goroutine才会被调度执行
- go内存管理机制：salutation变量从栈空间转移至堆空间，其保存的值为"good day"
因此，程序中的子goroutine在被调度执行时，salutation变量的值均为good day。
Tips
新建立一个goroutine有几千字节，这样的大小几乎总是够用的。如果出现不够用的情况，Go的runtime会自动增加(或缩小)用于存储堆栈的内存，从而允许goroutine存在适量内存中。因此，在C/C++等语言中容易发生的爆栈现象在Go中并不会发生，因为goroutine对应的堆栈空间是可以动态增长的。在相同的地址空间中创建数十万个goroutine是可以的，如果这些goroutine只是执行等同于线程的任务，那么系统资源的占用将会更小。
一种GC无法回收goroutine的情况：goroutine泄露
go func() {
// goroutine在此处永久阻塞
}()
// do work
一个计算goroutine占用内存空间大小的程序，通过运行结果可以看出一个goroutine是多么的轻量级。
package main
import (
"fmt"
"runtime"
"sync"
)
func main() {
memConsumed := func() uint64 { // 占用内存测量函数
runtime.GC()
var s runtime.MemStats
runtime.ReadMemStats(&s)
return s.Sys
}
var c <-chan interface{}
var wg sync.WaitGroup
noop := func() { wg.Done(); <-c } // 1 : goroutine将会一直被阻塞
const numGoroutines = 1e4 // 2 : 创建1W个goroutine
wg.Add(numGoroutines)
before := memConsumed() // 3 : 测量创建goroutine前，内存占用大小
for i := numGoroutines; i > 0; i-- {
go noop()
}
wg.Wait()
after := memConsumed() // 4 : 测量创建1Wgoroutine之后，内存占用情况
fmt.Printf("%.3fkb", float64(after-before)/numGoroutines/1000)
} // 测量结果: 每个goroutine占用内存空间大小约为2.61KB
测试goroutine上下文切换的性能
// 单纯模拟两个goroutine之间的数据传输，进行goroutine上下文切换性能的统计
func BenchmarkContextSwitch(b *testing.B) {
var wg sync.WaitGroup
begin := make(chan struct{})
c := make(chan struct{})
// 只是单纯地模拟两个goroutine之间传送数据
var token struct{}
sender := func() {
defer wg.Done()
<-begin //1: 阻塞
for i := 0; i < b.N; i++ {
c <- token //2: 发送
}
}
receiver := func() {
defer wg.Done()
<-begin //1: 阻塞
for i := 0; i < b.N; i++ {
<-c //3: 接收
}
}
wg.Add(2)
go sender()
go receiver()
b.StartTimer() //4: 启动定时器
close(begin) //5: 启动两个goroutine之间的数据传输, close channel --> done channel --> 进行信号广播
wg.Wait()
}
// 基准测试结果如下:
➜ learndemo **go test -bench=. -cpu=1 /Users/didi/MyWork/PersonalCode/src/go_demo/learndemo/context_switch_test.go**
goos: darwin
goarch: amd64
BenchmarkContextSwitch 10000000 **165 ns/op**
PASS
ok command-line-arguments 1.830s
➜ learndemo
6. channel相关知识
channel操作注意事项
作为拥有channnel的goroutine(生产者)，应该确保以下三件事情:
- 初始化该channel
- 执行写入操作或将所有权交给另一个goroutine
- 关闭该channel
作为channel的消费者，只需要考虑两件事情：
- channel什么时候被关闭(close)
- 处理基于任何原因出现的阻塞(block)
一个简单的生产者/消费者示例：
chanOwner := func() <-chan int { // 返回一个只读channel
resultStream := make(chan int, 5)//1
go func() {//2
defer close(resultStream)//3: defer close channel
for i := 0; i <= 5; i++ {
resultStream <- i // 生产数据
}
}()
return resultStream//4
}
// 生产者创建channel，并向channel中写入数据，生产结束后关闭channel(defer close)
resultStream := chanOwner()
for result := range resultStream {//5
fmt.Printf("Received: %d\n", result)
} // 消费者消费数据，可能会阻塞住，且在channel close时，执行退出操作
fmt.Println("Done receiving!")
7. select
select + time超时控制
var c <-chan int
select {
case <-c: //1
case <-time.After(1 * time.Second):
fmt.Println("Timed out.")
}
select+default
start := time.Now()
var c1, c2 <-chan int
select {
case <-c1:
case <-c2:
default:
fmt.Printf("In default after %v\n\n", time.Since(start))
}
for-select
done := make(chan interface{})
go func() {
time.Sleep(5 * time.Second)
close(done)
}()
workCounter := 0
loop:
for { // 不断循环，判断select-case条件是否满足
select {
case <-done:
break loop // break tag使用方法，跳出指定的多层循环
default:
}
// Simulate work
workCounter++
time.Sleep(1 * time.Second)
}
fmt.Printf("Achieved %v cycles of work before signalled to stop.\n", workCounter)
永久阻塞的select语句
select {} // select没有case分支，永久被阻塞
8. GOMAXPROCS
runtime.GOMAXPROCS(runtime.NumCPU()) // 指定G-P-M模型中的P的个数，从而决定了其能够利用的操作系统线程的最大数目，多核情况下goroutine运行的并行程度
