go——并发

并发与并行的区别：

并发：逻辑上具备同时处理多个任务的能力。

并行：物理上在同一时刻执行多个并发任务。

通常都会说程序是并发设计的，也就是说它允许多个任务同时执行，但实际上并不一定真在同一时刻发生。

在单核处理器上，它们能以间隔方式切换执行。

而并行则依赖多核处理器等物理设备，让多个任务真正在同一时刻执行，它代表了当前程序运行状态。

简单点说，并行是并发设计的理想执行模式。

多线程或多进程是并行的基本条件，但单线程也可用协程（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可终止进程，但不会执行延迟调用。