初识Go(8)

并发

goroutine
goroutine 是 Go 并行设计的核心。goroutine 说到底其实就是线程，但是他比线程更小，十
几个 goroutine 可能体现在底层就是五六个线程，Go 语言内部帮你实现了这些 goroutine
之间的内存共享。执行 goroutine 只需极少的栈内存(大概是 4~5KB)，当然会根据相应的数
据伸缩。也正因为如此，可同时运行成千上万个并发任务。 goroutine 比 thread 更易用、更高
效、更轻便。goroutine 是通过 Go 的 runtime 管理的一个线程管理器

package main
import (
"fmt"
"runtime"
)
func say(s string) {
for i := 0; i < 5; i++ {
runtime.Gosched()
fmt.Println(s)
}
}
func main() {
go say("world") //开一个新的 Goroutines 执行
say("hello") //当前 Goroutines 执行
}
// hello world hello world ^^^^^^^
很容易实现了并发

Channel
goroutine 运行在相同的地址空间，因此访问共享内存必须做好同步。那么 goroutine 之间如
何进行数据的通信呢，Go 提供了一个很好的通信机制 channel。 channel 可以与 Unix shell
中的双向管道做类比：可以通过它发送或者接收值。这些值只能是特定的类型：channel 类
型。定义一个 channel 时，也需要定义发送到 channel 的值的类型。注意，必须使用 make
创建 channel：
ci := make(chan int)
cs := make(chan string)
cf := make(chan interface{})

channel 通过操作符<-来接收和发送数据
ch <- v // 发送 v 到 channel ch.
v := <-ch // 从 ch 中接收数据，并赋值给 v
写个小例子：
func sum(a []int, c chan int) {
sum := 0
for _, v := range a {
sum += v
}
c <- sum // send sum to c
}
func main() {
a := []int{7, 2, 8, -9, 4, 0}
c := make(chan int)
go sum(a[:len(a)/2], c)
go sum(a[len(a)/2:], c)
x, y := <-c, <-c // receive from c
fmt.Println(x, y, x + y)
}

Buffered Channels
上面我们介绍了默认的非缓存类型的 channel，不过 Go 也允许指定 channel 的缓冲大小，
很简单，就是 channel 可以存储多少元素。ch:= make(chan bool, 4)，创建了可以存储 4 个
元素的 bool 型 channel。在这个 channel 中，前 4 个元素可以无阻塞的写入。 当写入第 5 个
元素时，代码将会阻塞，直到其他 goroutine 从 channel 中读取一些元素，腾出空间。
ch := make(chan type, value)
value == 0 ! 无缓冲（阻塞）
value > 0 ! 缓冲（非阻塞，直到 value 个元素）

c := make(chan int, 2)//修改 2 为 1 就报错，修改 2 为 3 可以正常运行
c <- 1
c <- 2
fmt.Println(<-c)
fmt.Println(<-c)

Range 和 Close
func fibonacci(n int, c chan int) {
x, y := 1, 1
for i := 0; i < n; i++ {
c <- x
x, y = y, x + y
}
close(c)//关闭chan，之后就无法发送数据了
}
func main() {
c := make(chan int, 10)
go fibonacci(cap(c), c)//cap，chan的缓冲大小
for i := range c {//能够不断从chan里读取数据，知道chan关闭
fmt.Println(i)
}
}
记住应该在生产者的地方关闭 channel，而不是消费的地方去关闭它，这样容易引起 panic
另外记住一点的就是 channel 不像文件之类的，不需要经常去关闭，只有当你确实没有任
何发送数据了，或者你想显式的结束 range 循环之类的

selsect
我们上面介绍的都是只有一个 channel 的情况，那么如果存在多个 channel 的时候，我们
该如何操作呢，Go 里面提供了一个关键字 select，通过 select 可以监听 channel 上的数据
流动。
select 默认是阻塞的，只有当监听的 channel 中有发送或接收可以进行时才会运行，当多
个 channel 都准备好的时候，select 是随机的选择一个执行的。我们还可以利用select来设置超时，
因为程序一旦阻塞就一直停在那里，所以我们需要设置阻塞超时。
func main() {
c := make(chan int)
o := make(chan bool)
go func() {
for {
select {
case v := <- c:
println(v)
case <- time.After(5 * time.Second):
println("timeout")
o <- true
break
}
}
}()
<- o
}