并行和并发
并行(parallel): 指在同一时刻, 有多条指令在多个处理上同时执行。
并发(concurrency): 指在同一时刻只能有一条指令执行, 但多个进行指令被快速的轮换执行, 使得在宏观上具有多个进程同时执行的效果, 但在微观上并不是同时执行的, 只是把时间分成若干端, 使多个进程快速交替的执行.
并行是两个队列同时使用两台咖啡机
并发是两个队列交替使用一台咖啡机
有人把Go比作21世纪的C语言, 第一是因为Go语言设计简单, 第二, 21世纪最重要的就是并行程序设计, 而Go从语言层面就支持了并行。
goroutine
goroutine是Go并行设计的核心。goroutine说到底其实就是线程, 但是它比线程更小, 十几个goroutine可能体现在底层就是五六个线程, Go语言内部帮你实现了这些goroutine之间的内存共享。
执行goroutine只需极少的栈内存(大概是4~5KB), 当然会根据相应的数据伸缩。也正因为如此, 可同时运行成千上万个并发任务。goroutine比thread更易用、更高效、更轻便。
goroutine是通过Go的runtime管理的一个线程管理器。goroutine通过go关键字实现了, 其实就是一个普通的函数。
go hello(a, b, c)
package main //必须有个main包
import (
"fmt"
"time"
)
func newTask() {
i := 0
for {
i++
fmt.Printf("new goroutine: i = %d\n", i)
time.Sleep(1 * time.Second) //延时1s
}
}
func main() {
//创建一个goroutine, 启动另外一个任务 (必须先创建协程和一个任务), 不能放在主协程的后面
go newTask()
i := 0
//main goroutine 循环打印
for { //死循环， 一致执行下去
i++
fmt.Printf("main goroutine: i = %d\n", 1)
time.Sleep(1 * time.Second) //延时1秒
}
}语法规则: 1 协程要放到主goroutine的前面;
2 执行的时间: 先执行一个主goroutine, 然后再执行协程;
3 主goroutine结束, 那么协程也结束;
主goroutine先退出
主goroutine退出后, 其他的工作goroutine也会自动退出:
【实例】
package main //必须有个main包
import (
"fmt"
// "runtime"
"time"
)
func newTask() {
i := 0
for {
i++
fmt.Printf("new goroutine: i = %d\n", i)
time.Sleep(1 * time.Second) //延时1s
}
}
func main() {
//创建一个goroutine, 启动另外一个任务(子协程)
go newTask()
//time.Sleep(10 * time.Second) //延时10s，让子协程继续执行
//runtime.Gosched() //让子协程继续执行， 推荐使用
fmt.Println("main goroutine exit") //主协程退出了， 子协程来不及调用执行
}执行结果：
main goroutine exit
在程序启动时, Go程序就会为main()函数创建一个默认的goroutine。当main()函数返回的时候该goroutine就结束了, 所有在main()函数中启动的goroutine会一同结束;
main函数所在的goroutine就像是权利的游戏中的夜王, 其他的goroutine都是异鬼, 夜王一死它转化的那些异鬼也就全部GG了。
所以我们要想办法让main函数等一等newTask函数, 最简单粗暴的方式就是time.Sleep了。
解决方法有两个:
time.Sleep(10 * time.Second) 延时10s，让子协程继续执行(取决于协程的执行的时间长)
runtime.Gosched() 让子协程继续执行, 推荐使用
【实例】
package main //必须有个main包
import (
"fmt"
"time"
)
func newTask() {
i := 0
for {
i++
fmt.Printf("new goroutine: i = %d\n", i)
time.Sleep(1 * time.Second) //延时1s
}
}
func main() {
//创建一个goroutine, 启动另外一个任务
go newTask()
i := 0
//main goroutine 循环打印
for {
i++
fmt.Printf("main goroutine: i = %d\n", 1)
time.Sleep(1 * time.Second) //延时1秒
if i == 2 {
break //主协程退出, 其他子协程也跟着退出
}
}
}输出结果：
main goroutine: i = 1
new goroutine: i = 1
main goroutine: i = 1
new goroutine: i = 2
runtime包
Gosched
runtime.Gosched()表示让CPU把时间片让给别人, 让出当前goroutine的执行权限, 调度器安排其他等待的任务运行, 并在下次某个时候从该位置恢复执行。
这就像跑接力赛, A跑了一会碰到代码runtime.Gosched()就把接力棒交给B了, A歇着了, B继续跑。
【实例】
package main //必须有个main包
import (
"fmt"
"runtime"
)
func main() {
//创建一个goroutine, 启动另外一个任务
go func(s string) {
for i := 0; i < 3; i++ {
fmt.Println(s)
}
}("world")
for i := 0; i < 2; i++ {
runtime.Gosched() //让子协程继续执行
fmt.Println("hello")
}
}【实例】 数组越界问题与参数传递
package main
import (
"fmt"
"runtime"
"time"
)
func main() {
var a [10]int
for i := 0; i < 10; i++ {
go func(i int) { // race condition! 如果这里不传递i, 就会出现数组越界 panic: runtime error: index out of range [10] with length 10
for {
a[i]++
//fmt.Printf("Hello from "+"goroutine %d\n", i)
runtime.Gosched() //交出控制权
}
}(i) //如果这里不传递i, 就会出现数组越界 panic: runtime error: index out of range [10] with length 10
}
time.Sleep(time.Millisecond)
fmt.Println(a)
}运行方法:
go run main.go
使用-race来检测数据访问冲突
go run -race main.go
Goexit
调用runtime.Goexit()将立即终止当前goroutine执行, 调度器确保所有已注册defer延迟调用被执行。
package main //必须有个main包
import (
"fmt"
"runtime"
)
func main() {
//创建一个goroutine, 启动另外一个任务
go func() {
defer fmt.Println("A.defer")
func() {
defer fmt.Println("B.defer")
runtime.Goexit() //终止当前goroutine, import "runtime"
fmt.Println("B") //不会执行
}()
fmt.Println("A") //不会执行
}()
//死循环, 目的不让主goroutine结束
for {
}
}运行结果:
B.defer
A.defer
GOMAXPROCS
调用 runtime.GOMAXPROCS()用来设置可以并行计算的CPU核数的最大值, 并返回之前的值。
package main //必须有个main包
import (
"fmt"
"runtime"
)
func main() {
n := runtime.GOMAXPROCS(1) //打印结果 111111111111111111111111100000000000000000
//n := runtime.GOMAXPROCS(2) //打印结果 010101010101010101010101010101
fmt.Printf("n = %d\n", n)
for {
go fmt.Print(0)
fmt.Print(1)
}
}GOMAXPROCS设置可同时执行的最大CPU数, 并返回先前的设置。
在第一次执行(runtime.GOMAXPROCS(1)), 最多同时只能有一个goroutine被执行。所以会打印很多1。
过了一段时间后, GO调度器将其设置为休眠, 并呼唤另一个goroutine, 这时候就开始打印很多0了, 在打印的时候, goruntine是被调度到操作系统线程上的。
在第二次执行(runtime.GOMAXPROCS(2)), 我们使用了两个CPU, 所以两个goroutine可以一起被执行, 以同样的频率交替打印0和1。
函数内部 return 之前 runtime(协程) 是否会执行?
package main //必须有个main包
import "fmt"
func Test(args ...int) {
for _, n := range args { //遍历参数列表
fmt.Println(n)
}
fmt.Println("判断协程是否执行? 已经执行!")
}
func sum(numbers ...int) int {
s := 0
for i := range numbers {
s += numbers[i]
}
// Test(1, 2, 3, 4, 5) // 这里得到了执行
go Test(1, 2, 3, 4, 5) // 函数内部 return 前 协程 runtime 没有执行;
return s
}
func main() {
//函数调用,可传0到多个参数
fmt.Println(sum(1, 2, 3, 4, 5)) // 15
//解决方法: 解决子协程来不及执行的问题
for {
}
}输出结果:
15
1
2
3
4
5
判断协程是否执行? 已经执行
结论: 主goroutine(main)退出后, 其他的工作goroutine也会自动退出;
函数的返回值在 goroutine 之前先执行