并发和并行的区别如下:
- 并发:逻辑上具备同时处理多个任务的能力。
- 并行:物理上在同一时刻执行多个并发任务。
我们通常会说程序是并发设计的,也就是说它允许多个任务同时执行,但实际上并不一定真在同一时刻发生。在单核处理器上,它们能以间隔方式切换执行。而并行则依赖多核处理器等物理设备,让多个任务真正在同一时刻执行,它代表了当前程序运行状态。简单点说,并行是并发设计的理想执行模式。
多线程或多进程是并行的基本条件,但单线程也可用协程做到并发。尽管协程在单个线程上通过主动切换来实现多任务并发,但它也有自己的优势。除了将因阻塞而浪费的时间找回来外,还免去了线程切换的开销,有着不错的执行效率。协程上运行的多个任务本质上是依旧串行的,加上可控自主调度,所以并不需要做同步处理。
很难说哪种方式更好一些,它们各有自使用的场景。通常情况下,用多进程来实现分布式和负载平衡,减轻单进程垃圾回收压力;用多线程(LWP)抢夺更多的处理器资源;用协程来提高处理器时间片利用率。
关键字 go 并非执行并发操作,而是创建一个并发任务单元。新建任务被放置在系统队列中,等待调度器安排合适系统线程去获取执行权。当前流程不会阻塞,不会等待该任务启动,切运行时也不会保证并发任务的执行次序。
每个任务单元除保存函数指针、调用参数外,还会分配执行所需的栈内存空间。相比系统默认 MB 级别的线程栈, goroutine 自定义栈初始化仅须 2KB,所以才能创建成千上万的并发任务。自定义栈采取按需分配策略,在需要是进行扩容,最大能到 GB 规模。
Wait
进程退出时不会等待并发任务结束,可用通道(channel)阻塞,然后发出退出信号。
package main
import "time"
func main() {
exit := make(chan struct{}) // 创建通道,因为仅是通知,数据并没有实际意义
go func() {
time.Sleep(time.Second)
println("go routine done.")
close(exit) // 管理通道,发出信号
}()
println("main....")
<-exit // 如通道管理,立即解除阻塞
println("main exit.")
}
输出结果为:
main…
go routine done.
main exit.
尽管 WaitGroup.Add 实现了原子操作,但建议在 goroutine 外累加计数器,以免 Add 尚未执行,Wait 已经退出。
package main
import "sync"
func main() {
var wg sync.WaitGroup
go func() {
wg.Add(1) // 来不及设置
println("hi!")
}()
wg.Wait()
println("exit.")
}
输出为:
exit.
hi!
可在多处使用 Wait 阻塞,它们都能接收到通知。
package main
import (
"sync"
"time"
)
func main() {
var wg sync.WaitGroup
wg.Add(1)
go func() {
wg.Wait()
println("wait exit...")
}()
go func() {
time.Sleep(time.Second)
println("done..")
wg.Done()
}()
wg.Wait()
println("main exit...")
}
输出为:
done…
wait exit…
main exit…
GOMAXPROCS
运行时可能会创建很多线程,但任何时候仅有限的几个线程参与并发任务执行。该数量默认与处理器核数相等,可用 runtine.GOMAXPROCS 函数(或环境变量)修改。
如参数小于1,GOMAXPROCS 仅返回当前设置值,不做任何调整。
Local Storage
与线程不同,goroutine 任务无法设置优先级,无法获取编号。没有局部存储(TLS),甚至连返回值都会被抛弃。但除优先级外,其他功能都很容易实现。
package main
import (
"fmt"
"sync"
)
func main() {
var wg sync.WaitGroup
var gs [5]struct{ // 用于实现类似 TLS 功能
id int // 编号
result int // 返回值
}
for i := 0; i < len(gs); i++ {
wg.Add(1)
go func(id int) {
defer wg.Done()
gs[id].id = id
gs[id].result = (id + 1) * 100
}(i)
}
wg.Wait()
fmt.Printf("%+v\n", gs)
}
输出为:
[{id:0 result:100} {id:1 result:200} {id:2 result:300} {id:3 result:400} {id:4 result:500}]
如使用 map 做局部存储容器,建议做同步处理,因为运行时会对其做并发读写检查。
Gosched
暂停,释放线程去执行其他任务。当前任务被放回队列,等待下次调度时恢复执行。
package main
import "runtime"
func main() {
runtime.GOMAXPROCS(1)
exit := make(chan struct{})
go func() {
defer close(exit)
go func() {
println("b")
}()
for i := 0; i < 4; i++ {
println("a:", i)
if i == 1 {
runtime.Gosched()
}
}
}()
<-exit
}
输出结果为:
a: 0
a: 1
b
a: 2
a: 3
Goexit
Goexit 立即终止当前任务,运行时确保所有已注册延迟函数被执行。该函数不会影响其他并发任务,不会引发 panic,自然也就无法捕获。
package main
import "runtime"
func main() {
exit := make(chan struct{})
go func() {
defer close(exit) // 执行
defer println("a") // 执行
func() {
defer func() {
println("b", recover() == nil) // 执行, recover 返回 nil
}()
func() { // 在多层调用中执行 Goexit
println("c")
runtime.Goexit() // 立即终止整个调用堆栈
println("c done.") // 不会执行
}()
println("b done.") // 不会执行
}()
println("a done.") // 不会执行
}()
<-exit
}
输出为:
c
b true
a
main exit.
如果在 main.main 里调用了 Goexit,它会等待其他任务结束,然后让进城直接崩溃。
package main
import (
"fmt"
"runtime"
"time"
)
func main() {
for i := 0; i < 2; i++ {
go func(x int) {
for n := 0; n < 2; n++ {
fmt.Printf("%c: %d\n", 'a' + x, n)
time.Sleep(time.Millisecond)
}
}(i)
}
runtime.Goexit()
println("main exit.")
}
输出:
b: 0
a: 0
a: 1
b: 1
fatal error: no goroutines (main called runtime.Goexit) - deadlock!
无论身处哪一层,Goexit 都能立即终止整个调用堆栈,这与 return 仅退出当前函数不同。标注库函数 osExit 可终止进程,但不会执行延迟调用。