并发与并行的区别：
并发：逻辑上具备同时处理多个任务的能力。
并行：物理上在同一时刻执行多个并发任务。
通常都会说程序是并发设计的，也就是说它允许多个任务同时执行，但实际上并不一定真在同一时刻发生。
在单核处理器上，它们能以间隔方式切换执行。
而并行则依赖多核处理器等物理设备，让多个任务真正在同一时刻执行，它代表了当前程序运行状态。
简单点说，并行是并发设计的理想执行模式。
多线程或多进程是并行的基本条件，但单线程也可用协程（coroutine）做到并发。
尽管协程在单个线程上通过主动切换来实现多任务并发，但它也有自己的优势。
除了将因阻塞而浪费的时间找回来外，还免去了线程切换开销，有着不错的执行效率。
协程上运行的多个任务本质上依旧串行，加上可控自主调度，所以并不需要做同步处理。
即使采用多线程也未必能并行。Python就因GIL限制，默认只能并发而不能并行，所以很多时候转而使用“多进程”+“协程”架构。
通常情况下，用多进程来实现分布式和负载均衡，减轻单进程垃圾回收压力；
用多线程（LWP）抢夺更多的处理器资源；用协程来提高处理器时间片利用率。
简单将goroutine归纳为协程并不合适。运行时会创建多个线程来执行并发任务，且任务单元可被调度到其它线程并行执行。
这更像是多线程和协程的综合体，能最大限度提升执行效率，发挥多核处理能力。
只须在函数调用前添加go关键字即可创建并发任务。
go fmt.PrintLn("hello")
关键字go并非执行并发操作，而是创建一个并发任务单元。
新建任务被放置在系统队列中，等待调度器安排合适系统线程去获取执行权。
当前流程不会阻塞，不会等待该任务启动，且运行时也不保证并发任务的执行次序。
每个任务单元除保存函数指针、调用参数外，还会分配执行所需的栈内存空间。
相比系统默认MB级别的线程栈，goroutine自定义栈初始仅须2KB，所以才能创建成千上万的并发任务。
自定义栈采取按需分配策略，在需要时进行扩容，最大能到GB规模。
与defer一样，goroutine也会因“延迟执行”而立即计算并复制执行参数。
package main
import (
"fmt"
"time"
)
var c int //初始为0
func counter() int {
c++
return c
}
func main() {
a := 100
go func(x, y int) { //匿名函数直接执行
//hour min second 时分秒
time.Sleep(time.Second) //休息一秒钟
fmt.Println("go", x, y) //执行counter 100 1 //goroutine在main之后执行
}(a, counter()) //立即计算并复制参数
a += 100
fmt.Println("main:", a, counter()) //200 2
time.Sleep(time.Second * 3) //等待goroute结束
}
/*
main: 200 2
go 100 1
为什么先打印main？
go创建一个并发单元，但是不会马上执行，而是会放置在队列中
*/
进程退出时不会等待并发任务结束，可用通道（channel）阻塞，然后发出退出信号。
package main
import (
"fmt"
"time"
)
func main() {
// exit := make(chan struct{}) //创建通道。因为仅仅是通知，数据并没有实际意义。
go func() {
time.Sleep(time.Second)
fmt.Println("goroutine done.")
// close(exit) //关闭通道发出信号
}()
fmt.Println("main...")
// <-exit //如通道关闭，立即解除阻塞。
fmt.Println("main exit...")
}
<-exit接收操作符，如果exit代表了元素类型为byte的通道类型值，则此表达式就表示从exit中接收一个byte类型值的操作。
如果不创建通道，main直接结束之后进程就结束了，而不会等待并发任务的结束，这样就不会执行并发任务。
所以，我们可以创建一个通道，当通道关闭后才会解除阻塞，整个程序才会结束
除关闭通道外，写入数据也可解除阻塞。
如果等待多个任务结束，推荐使用sync.WaitGroup。
通过设定计数器，让每个goroutine在退出前递减，直至归零时解除阻塞。
package main
import (
"fmt"
"sync"
"time"
)
func main() {
var wg sync.WaitGroup
for i := 0; i < 10; i++ {
wg.Add(1) //累加计数，每循环以此加一
go func(id int) { //创建多个任务单元
defer wg.Done() //递减计数，这个任务计数之前减一
time.Sleep(time.Second)
fmt.Println("goroutine", id, "done")
}(i)
}
fmt.Println("main...")
wg.Wait() //阻塞，直至wg归零
fmt.Println("main exit")
}
/*
main...
goroutine 6 done
goroutine 1 done
goroutine 2 done
goroutine 4 done
goroutine 9 done
goroutine 8 done
goroutine 0 done
goroutine 7 done
goroutine 5 done
goroutine 3 done
main exit
*/
尽管WaitGroup.Add实现了原子操作，但建议在goroutine外累加计数器，以免Add尚未执行，wait已经退出。
go func(id int) {
wg.Add(1)
defer wg.Done()
}
可在多处使用wait阻塞,它们都可以接收到通知。
package main
import (
"fmt"
"sync"
"time"
)
func main() {
var wg sync.WaitGroup
wg.Add(1)
go func() {
wg.Wait()
fmt.Println("wait exit")
}()
go func() {
time.Sleep(time.Second * 3)
fmt.Println("done.")
wg.Done()
}()
wg.Wait()
fmt.Println("main exit.")
}
/*
done.
wait exit
main exit.
*/
GOMAXPROCS 线程数量
运行时可能会创建很多线程，但任何时候仅有限的几个线程参与并发任务执行。
该数量默认与处理器核数相等，可用runtime.GOMAXPROCS函数（或环境变量）修改。
package main
import (
"fmt"
"math"
"runtime"
"sync"
"time"
)
//测试目标函数
func count() {
x := 0
for i := 0; i < math.MaxUint32; i++ {
x += 1
}
fmt.Println(x)
}
//循环执行
func test(n int) {
for i := 0; i < n; i++ {
count()
}
}
//并发执行
func test2(n int) {
var wg sync.WaitGroup
wg.Add(n) //计数为4
for i := 0; i < n; i++ {
go func() {
count()
wg.Done()
}()
}
wg.Wait()
}
func main() {
n := runtime.GOMAXPROCS(0) //4
fmt.Println(time.Now())
// test(n) //6s
test2(n) //3s
fmt.Println(time.Now())
}
Local Storage 局部存储器
与线程不同，goroutine任务无法设置优先级，无法获取编号，没有局部存储（TLS），甚至连返回值都会被抛弃。
package main
import (
"fmt"
"sync"
)
func main() {
var wg sync.WaitGroup
var gs [5]struct { //使用数组来进行局部存储
id int //编号
result int //返回值
}
fmt.Println(gs)
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)
}
/*
[{0 0} {0 0} {0 0} {0 0} {0 0}]
[{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 (
"fmt"
"runtime"
)
func main() {
runtime.GOMAXPROCS(1)
exit := make(chan struct{})
go func() { /任务a
defer close(exit)
go func() { //任务b
fmt.Println("b")
}()
for i := 0; i < 4; i++ {
fmt.Println("a:", i)
if i == 1 {
runtime.Gosched() //让出当前线程，调度执行b
}
}
}()
<-exit
}
/*
a: 0
a: 1
b //这个b有可能打印不出来
a: 2
a: 3
*/
该函数很少被使用，因为运行时会主动向长时间运行的任务发出抢占调度。
Goexit
立即终止当前任务，运行时确保所有已注册延迟调用被执行。
该函数不会影响其它并发任务，不会引发panic，自然也就无法捕获。
package main
import (
"fmt"
"runtime"
)
func main() {
exit := make(chan struct{})
go func() {
defer close(exit)
defer fmt.Println("a") //执行3
func() {
defer func() {
fmt.Println("b", recover() == nil) //defer总会执行 2
}()
func() {
fmt.Println("c") //执行1
runtime.Goexit() //立即终止当前任务
fmt.Println("c done.") //不会执行
}()
fmt.Println("b done.") //不会执行
}()
fmt.Println("a done.") //不会执行
}()
<-exit
fmt.Println("main exit") //主程序
}
/*
c
b true
a
main exit
*/
如果在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() //等待所有任务结束
fmt.Println("main exit.")
}
/*
b: 0
a: 0
a: 1
b: 1
fatal error: no goroutines (main called runtime.Goexit) - deadlock!
*/
无论身处那一层，Goexit都能立即终止整个调用堆栈，这与return仅退出当前函数不同。
标准库函数os.Exit可终止进程，但不会执行延迟调用。