package main
import (
"fmt"
"time"
)
func say(s string) {
for i := 0; i < 5; i++ {
time.Sleep(100 * time.Millisecond)
fmt.Println(s)
}
}
func main() {
go say("world")
say("hello")
}
笔记
Go 程（goroutine）是由 Go 运行时管理的轻量级线程。
go f(x, y, z)
会启动一个新的 Go 程并执行
f(x, y, z)
f, x, y 和 z 的求值发生在当前的 Go 程中，而 f 的执行发生在新的 Go 程中。
Go 程在相同的地址空间中运行，因此在访问共享的内存时必须进行同步。sync 包提供了这种能力，不过在 Go 中并不经常用到，因为还有其它的办法（见下一页）。
思考
1. 多次执行的顺序都是一致的。所以说和线程基本上不会乱序执行的？
2. 这个问题很奇怪
验证
为了方便验证我的想法，重新改写了代码如下(时间单元为纳秒):
//例子1
package main
import (
"fmt"
"time"
)
func say1(s string) {
for i := 0; i < 5; i++ {
fmt.Println("In say1()-",i,time.Now().UnixNano())
time.Sleep(100 * time.Millisecond)
fmt.Println(s)
fmt.Println("end say1()",i,time.Now().UnixNano())
}
}
func say2(s string) {
for i := 0; i < 5; i++ {
fmt.Println("In say2()-",i,time.Now().UnixNano())
time.Sleep(100 * time.Millisecond)
fmt.Println(s)
fmt.Println("end say2()",i,time.Now().UnixNano())
}
}
func main() {
fmt.Println("In main()---",time.Now().UnixNano())
go say1("world")
say2("hello")
}
输出
In main()--- 1540706604305141891
In say2()- 0 1540706604305181351
In say1()- 0 1540706604305219272
hello
world
end say1() 0 1540706604405319232
In say1()- 1 1540706604405324817
end say2() 0 1540706604405313310
In say2()- 1 1540706604405345566
hello
end say2() 1 1540706604505434102
In say2()- 2 1540706604505443829
world
end say1() 1 1540706604505498411
In say1()- 2 1540706604505508293
hello
end say2() 2 1540706604605564777
In say2()- 3 1540706604605575973
world
end say1() 2 1540706604605609988
In say1()- 3 1540706604605615117
world
end say1() 3 1540706604705700643
In say1()- 4 1540706604705708692
hello
end say2() 3 1540706604705738341
In say2()- 4 1540706604705742821
world
end say1() 4 1540706604805845281
hello
end say2() 4 1540706604805858926
//例子2
package main
import (
"fmt"
"time"
)
func main() {
fmt.Println("In main()")
go longWait()
go shortWait()
fmt.Println("About to sleep in main()")
// sleep works with a Duration in nanoseconds (ns) !
time.Sleep(10 * 1e9)
fmt.Println("At the end of main()")
}
func longWait() {
fmt.Println("Beginning longWait()")
time.Sleep(5 * 1e9) // sleep for 5 seconds
fmt.Println("End of longWait()")
}
func shortWait() {
fmt.Println("Beginning shortWait()")
time.Sleep(2 * 1e9) // sleep for 2 seconds
fmt.Println("End of shortWait()")
}
package main
import "fmt"
func sum(s []int, c chan int) {
sum := 0
for _, v := range s {
sum += v
}
c <- sum // 将和送入 c
}
func main() {
s := []int{7, 2, 8, -9, 4, 0}
c := make(chan int)
go sum(s[:len(s)/2], c)
go sum(s[len(s)/2:], c)
x, y := <-c, <-c // 从 c 中接收
fmt.Println(x, y, x+y)
}
笔记
信道是带有类型的管道，你可以通过它用信道操作符 <- 来发送或者接收值。
ch <- v // 将 v 发送至信道 ch。
v := <-ch // 从 ch 接收值并赋予 v。
（“箭头”就是数据流的方向。）
和映射与切片一样，信道在使用前必须创建：
ch := make(chan int)
默认情况下，发送和接收操作在另一端准备好之前都会阻塞。这使得 Go 程可以在没有显式的锁或竞态变量的情况下进行同步。
以下示例对切片中的数进行求和，将任务分配给两个 Go 程。一旦两个 Go 程完成了它们的计算，它就能算出最终的结果。
package main
import (
"fmt"
)
func fibonacci(n int, c chan int) {
x, y := 0, 1
for i := 0; i < n; i++ {
c <- x
x, y = y, x+y
}
close(c)
}
func main() {
c := make(chan int, 10)
go fibonacci(cap(c), c)
for i := range c {
fmt.Println(i)
}
}
笔记
发送者可通过 close 关闭一个信道来表示没有需要发送的值了。接收者可以通过为接收表达式分配第二个参数来测试信道是否被关闭：若没有值可以接收且信道已被关闭，那么在执行完
v, ok := <-ch
之后 ok 会被设置为 false。
循环 for i := range c 会不断从信道接收值，直到它被关闭。
*注意：* 只有发送者才能关闭信道，而接收者不能。向一个已经关闭的信道发送数据会引发程序恐慌（panic）。
*还要注意：* 信道与文件不同，通常情况下无需关闭它们。只有在必须告诉接收者不再有值需要发送的时候才有必要关闭，例如终止一个 range 循环。
例子中斐波那契函数，计算指定数以内的队列，计算完成后，会关闭信道。
main函数中，创建一个缓冲为10的信道，然后执行一个协程，不断从信道获取计算的数字
我理解的信道类似于一个全局的栈，存放可访问的变量。
select.go
package main
import "fmt"
func fibonacci(c, quit chan int) {
x, y := 0, 1
for {
select {
case c <- x:
x, y = y, x+y
case <-quit:
fmt.Println("quit")
return
}
}
}
func main() {
c := make(chan int)
quit := make(chan int)
go func() {
for i := 0; i < 10; i++ {
fmt.Println(<-c)
}
quit <- 0
}()
fibonacci(c, quit)
}
笔记
select 语句使一个 Go 程可以等待多个通信操作。
select 会阻塞到某个分支可以继续执行为止，这时就会执行该分支。当多个分支都准备好时会随机选择一个执行。
这，这咋理解呢？从不同的信道选择发送数据的那个信道。
在select中，理论上c <- x又是简写吧。<- c and c <- x 选择c，并把x的值发送到信道c
main函数中，创建2个信道，执行一个匿名函数，获取从c信道接受到的数字。
如果信道没有发送新的数据过来，是否会一直阻塞？
default-selection.go
package main
import (
"fmt"
"time"
)
func main() {
tick := time.Tick(100 * time.Millisecond)
boom := time.After(500 * time.Millisecond)
for {
select {
case <-tick:
fmt.Println("tick.")
case <-boom:
fmt.Println("BOOM!")
return
default:
fmt.Println(" .")
time.Sleep(50 * time.Millisecond)
}
}
}
笔记
当 select 中的其它分支都没有准备好时，default 分支就会执行。
为了在尝试发送或者接收时不发生阻塞，可使用 default 分支：
select {
case i := <-c:
// 使用 i
default:
// 从 c 中接收会阻塞时执行
}
