接下来学习并发编程, 并发编程是go语言最有特色的地方, go对并发编程是原生支持.
goroutine是go中最近本的执行单元
每一个go程序至少有一个goroutine, 那就是主goroutine. 当程序启动时, 他会自动创建. 也就是main方法
main方法也是一个goroutine
package main
import (
"fmt"
"time"
)
func main() {
for i := 0; i<1000; i++ {
go func(i int) {
for {
fmt.Printf("goroutine: %d \n", i)
}
}(i)
}
time.Sleep(time.Second)
}
goroutine和Coroutine比较相似, Coroutine是协程. 其他语言都有这个叫法, 但不是所有语言都支持.
线程拥有自己独立的栈和共享的堆,共享堆,不共享栈,线程的切换一般也由操作系统调度。
package main
import (
"fmt"
"time"
)
func main() {
var a [10]int
for i := 0; i<10; i++ {
go func(i int) {
for {
a[i] ++
}
}(i)
}
time.Sleep(time.Second)
fmt.Println(a)
}
猜一下, 这段代码的运行结果. 结合非抢占式多任务处理
结果是: 这段代码是一个死循环. 当第一次进入到循环体以后. 由于goroutine是非抢占式, 所以第一次循环一直持有, 没有主动释放. 所以, 这段代码的结果是死循环
runtime.Gosched()
这样就可以手动交出控制权, 让其他协程运行
如果我们在协程中没有传变量i会怎么样呢?
没错, 报错了. 为什么报错了呢? 我们通过race 来看一下
go run -race goroutine.go
可以看到报错的原因是, 同一块空间, 在第七个协程读, 在主协程写. 这样就是有问题的了.
接下来分析一下这段代码为什么报错?
package main
import (
"fmt"
"runtime"
"time"
)
func main() {
var a [10]int
for i := 0; i < 10; i++ {
go func() {
for {
a[i] ++
runtime.Gosched()
}
}()
}
time.Sleep(time.Second)
fmt.Println(a)
}
程序启动的时候都做了哪些事?
首先. 开了10个协程. i从1遍历到10, 发现10 < 10 , for循环退出了. 但是, 由于协程里面的i是直接饮用的外部的i. 当for循环完成以后, i的值变成10了. 协程里对a[10]进行++, 那自然就会报异常了.
所以, 为了安全起见, 我们把每一次开协程的时候, 把i带过去.
修改后的
func main() {
var a [10]int
for i := 0; i < 10; i++ {
go func(i int) {
for {
a[i] ++
runtime.Gosched()
}
}(i)
}
time.Sleep(time.Second)
fmt.Println(a)
}
这时候我们在-race一下, 查看是否还有数据访问冲突
依然有数据访问冲突. 主goroutine在读, 第7个协程在写. 所以这样是有问题的. 这个问题可以通过chan来解决.
我们知道每一个函数都是一个子程序, 子程序是协程的一个speical case, 那怎样才算是一个special case呢?
1) 普通函数的调用: 首先main方法启动, main方法里调了另一个doWork方法. 当doWork方法都执行完了以后, 在继续回到main方法里, 一次往下执行. 所以普通的函数是单线程.
2) 协程的调用: 协程也是main和doWork, 但是main和doWork之间不是单向的箭头. 中间有一个双向的通道.
main和dowork之间可以双向的流通. 控制权也可以双向的流通.就像两个线程, 各做各的事情, 中间还可以通信, 控制权可以相互交换.
那么main和dowork运行在哪里呢?
可能是一个线程, 也可能是多个线程. 这个事情不需要程序员管了, 调度器可能开一个线程,也可能开两个线程进行执行.
1) 首先有一个go语言的进程, 他下面会有一个调度器, 调度器的作用就是调度协程
2) 调度器会分配, 一个协程在一个线程里运行, 也可能是两个协程在一个线程里运行, 也可能是多个协程在一个线程里运行. 这是调度器做的事, 程序员不用管.
1) 在函数前加go, 就可以交给调度器运行
2) 不需要再定义时区分是否是异步函数. 这个是相对于python来说的
3) 调度器在合适的点进行切换. 由调度器操作执行, 一般不需要我们来操作
4)使用-race来检测数据访问冲突. 这个在上面已经讲过了.
调度器在哪些个点有可能切换协程呢?
1. I/O, select : I/O和select可能会切换. 之前fmt.Println("")为什么会切换呢? 因为他是一个I/O
2) channel
3) 等待锁
4) 函数调用(有时)
5) runtime.Gosched() 手动提供切换的点
总结: 以上只是一个参考, 不能保证遇到这些地方一定切换, 也不能保证其他地方就不切换.
package main
import (
"fmt"
"time"
)
func main() {
for i := 0; i < 1000; i++ {
go func(i int) {
for {
fmt.Printf("hello goroutine: %d \n", i)
}
}(i)
}
time.Sleep(time.Minute)
}
上面这段程序, 看重点
1) 开了1000个协程
2) 主线程等待1分钟
我们top一下, 看看效果
红色圈出的是go运行的程序
cpu的占用率是186.6%, 12/3 表示开了多少个线程. 我们发现开了12个线程, 但是最终运行的线程数最多是4个. 原因是我的cpu是4核的.