初识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

}