并发(concurrency)是指一次处理大量事情的能力。让我们用一个
例子来说明。
并行(parallelism)指的是同时处理多个事情。虽然听起来像并发，
但是它们是不同的。
并行 并不一定比 并发 快，举一个例子，当文件下载完成时，应该使用弹出窗口来通知用户。而这种通信发生在负责下载的组件和负责渲染用户界面的组件之间。在并发系统中，这种通信的开销很低。而如果这两个组件并行地运行在 CPU 的不同核上，这种通信的开销却很大。因此并行程序并不一定会执行得更快。
Go 原生支持并发。在Go中，使用 Go 协程(Goroutine)和信道 (channel)来处理并发。 函数 main 就以 goroutine 运 。另有与之配套的channel 类型， 以实现 "以通讯来共享内存" 的 CSP 模式。
调度器不能保证多个 goroutine 执行次序，且进程退出时不会等待它们结束。
一、创建协程
func hello() {
fmt.Println("Hello world goroutine")
}
func main() {
go hello()
fmt.Println("main function")
}
1.go hello()开启一个新协程，现在 hello() 函数将和 main() 函数一起运行。main 函数在单独的协程中运行，这个协程称 为主协程。
2.在主协程存在时才能运行其他协程，主协程终止则程序终止，其他协程也将终止。
3.这段代码不会打印hello里的字符串，因为主协程运行完的时候hello()协程还没运行完。
运用time包的Sleep解决上述问题：
在主协程中使用 Sleep 函数等待其他协程结束的方法是不正规的， 我们用在这里只是为了说明Go协程是如何工作的
func main() {
go hello()
time.Sleep(1 * time.Second)//休眠1秒钟
fmt.Println("main function")
}
二、开启多个协程
package main
import(
"fmt"
"time"
)
func numbers() {
for i := 1; i <= 5; i++ {
time.Sleep(250 * time.Millisecond)
fmt.Printf("%d ", i) }
}
func alphabets() {
for i := 'a'; i <= 'e'; i++ {
time.Sleep(400 * time.Millisecond)
fmt.Printf("%c ", i) }
}
func main() {
go numbers()
go alphabets() //开启多个协程
time.Sleep(time.Millisecond * 3000)
fmt.Println("Main Over")
}
三、runtime.Goexit终止goroutine执行
func main() {
wg := new(sync.WaitGroup)
wg.Add(1)
go func() {
defer wg.Done()
defer fmt.println("A.defer")
func() {
defer fmt.println("B.defer")
runtime.Goexit()//终止当前协程
println("B") //不会执行
}()
println("A") //不会执行
wg.Wait()
}
//defer延迟调用仍然执行
四、WaitGroup
“三”中代码涉及的sync包的WaitGroup
WaitGroup 用于等待一批 Go 协程执行结束。程序控制会一直阻塞，直到这些协程全部执行完毕。
WaitGroup是一个结构体，初始值为零，使用计数器工作。
func process(i int, wg *sync.WaitGroup) {
fmt.Println("started Goroutine ", i)
time.Sleep(2 * time.Second) fmt.Printf("Goroutine %d ended\n", i)
wg.Done() //计数-1
}
func main() {
no := 3
var wg sync.WaitGroup //声明一个WaitGroup 要import "sync"
for i := 0; i < no; i++ {
wg.Add(1) //计数+1
go process(i, &wg)
}
wg.Wait() //计数为0时主协程解除阻塞 往下执行
fmt.Println("All go routines finished executing")
}
