学习博客：
https://www.jianshu.com/p/eba6e2af6d63
https://www.runoob.com/w3cnote/go-channel-intro.html
package main
import "fmt"
import "time"
import "sync"
import "math/rand"
var m map[int]int = make(map[int]int)
const (
Num = 100000
)
var lock sync.Mutex
func map_write(c chan bool) { //开一个协程顺序写map
fmt.Println("write begin")
for i:=0;i<Num ;i++ {
lock.Lock()
m[i]=i
fmt.Printf("write %d : %d\n", i, m[i])
lock.Unlock()
}
fmt.Println("write end")
c <- true;
}
func map_read(c chan bool) { //开一个协程顺序读map
fmt.Println("read begin")
for i:=0;i<Num ;i++ {
lock.Lock() //加锁
fmt.Printf("read %d : %d\n", i, m[i])
lock.Unlock() //解锁
}
fmt.Println("read end")
c <- true;
}
func map_rand_read(c chan bool) { //开一个协程随机读map
fmt.Println("rand_read begin")
for i:=0;i<Num ;i++ {
rand.Seed(time.Now().UnixNano())
lock.Lock() //加锁
var tmp int = rand.Intn(100)
fmt.Printf("rand_read %d : %d\n", tmp, m[tmp])
lock.Unlock() //解锁
}
fmt.Println("rand_read end")
c <- true;
}
func main() {
c := make(chan bool, 3)
fmt.Println("main begin")
go map_write(c)
go map_read(c)
go map_rand_read(c)
<- c
<- c
<- c
fmt.Println("main end")
}
定义和使用
chan T // 可以接收和发送类型为 T 的数据
chan<- float64 // 只可以用来发送 float64 类型的数据
<-chan int // 只可以用来接收 int 类型的数据
<-总是优先和最左边的类型结合。
chan<- chan int // 等价 chan<- (chan int)
chan<- <-chan int // 等价 chan<- (<-chan int)
<-chan <-chan int // 等价 <-chan (<-chan int)
chan (<-chan int)
x, ok := <-ch
x, ok = <-ch
var x, ok = <-ch
使用make初始化Channel,并且可以设置容量:
make(chan int, 100)
容量(capacity)代表Channel容纳的最多的元素的数量，代表Channel的缓存的大小。
如果没有设置容量，或者容量设置为0, 说明Channel没有缓存，
只有sender和receiver都准备好了后它们的通讯(communication)才会发生(Blocking)。
如果设置了缓存，就有可能不发生阻塞， 只有buffer满了后 send才会阻塞， 而只有缓存空了后receive才会阻塞。
一个nil channel不会通信。
blocking和non-blocking
默认情况下，发送和接收会一直阻塞着，直到另一方准备好。
这种方式可以用来在gororutine中进行同步，而不必使用显式锁或者条件变量。
官方的例子中x, y := <-c, <-c会一直等待计算结果发送到channel中。
import "fmt"
func sum(s []int, c chan int) {
sum := 0
for _, v := range s {
sum += v
}
c <- sum // send sum to 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 // receive from c
fmt.Println(x, y, x+y) // x 和 y 分别取 c 的第一个和第二个入值，但哪个go先算完，则没有对应关系
}
Buffered Channels
make的第二个参数指定缓存的大小：ch := make(chan int, 100)。
通过缓存的使用，可以尽量避免阻塞，提供应用的性能。
Range
for …… range语句可以处理Channel。
func main() {
go func() {
time.Sleep(1 * time.Hour)
}()
c := make(chan int)
go func() {
for i := 0; i < 10; i = i + 1 {
c <- i
}
close(c)
}()
for i := range c {
fmt.Println(i)
}
fmt.Println("Finished")
}
range c产生的迭代值为Channel中发送的值，它会一直迭代直到channel被关闭。
上面的例子中如果把close©注释掉，程序会一直阻塞在for …… range那一行。
select
select语句选择一组可能的send操作和receive操作去处理。
它类似switch，但是只是用来处理通讯(communication)操作。
它的case可以是send语句，也可以是receive语句，亦或者default。
receive语句可以将值赋值给一个或者两个变量。它必须是一个receive操作。
最多允许有一个default case，它可以放在case列表的任何位置。
package main
import "fmt"
func fibonacci(c, quit chan int) {
x, y := 0, 1
for {
select {
case c <- x: // 把 x 写入 chan c
x, y = y, x+y
case <-quit: // 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(i, " : ", <-c) // c 中没数据会一直阻塞
}
quit <- 0 // 读取 10次 c 之后，给 quit 发 0
}()
fibonacci(c, quit) // 传递的是两个 chan
}
打印结果(default 被删掉了好多)：
0 : 0
1 : 1
2 : 1
3 : 2
4 : 3
5 : 5
6 : 8
7 : 13
8 : 21
9 : 34
quit
如果有同时多个case去处理，比如同时有多个channel可以接收数据，
那么Go会伪随机的选择一个case处理(pseudo-random)。
default case存在的情况下，如果没有case需要处理，则会选择default去处理。
如果没有default case，则select语句会阻塞，直到某个case需要处理。
注意：
nil channel上的操作会一直被阻塞，如果没有default case，只有nil channel的select会一直被阻塞。
select语句和switch语句一样，它不是循环，它只会选择一个case来处理，
如果想一直处理channel，可以在外面加一个无限的for循环。
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
default:
fmt.Println("default")
}
}
}
func main() {
c := make(chan int) // 阻塞
quit := make(chan int) // 阻塞
go func() {
for i := 0; i < 10; i++ {
fmt.Println(i, " : ", <-c) // c 中没数据会一直阻塞
}
quit <- 0 // 读取 10次 c 之后，给 quit 发 0
}()
fibonacci(c, quit) // 传递的是两个 chan
}
打印结果(default 被删掉了好多)：
default
default
default
0 : 0
default
default
default
default
1 : 1
default
default
default
default
default
2 : 1
default
default
3 : 2
default
default
4 : 3
default
default
5 : 5
default
default
default
default
default
6 : 8
default
default
7 : 13
default
default
default
8 : 21
default
default
9 : 34
default
quit
timeout
select的一个应用就是超时处理。
如果没有case需要处理，select语句就会一直阻塞着。这时可能就需要一个超时操作，用来处理超时。
它利用time.After方法，返回一个类型为<-chan Time的单向的chan，
在指定的时间发送一个当前时间给返回的chan中。
eg :
package main
import "time"
import "fmt"
func main() {
c1 := make(chan string, 1)
go func() {
time.Sleep(time.Second * 2)
c1 <- "result 1"
}()
select {
case res, ok := <-c1:
fmt.Println(res, ":", ok)
case <-time.After(time.Second * 1):
fmt.Println("timeout 1") // timeout 1
}
}
package main
import "time"
import "fmt"
func main() {
c1 := make(chan string, 1)
go func() {
time.Sleep(time.Second * 1)
c1 <- "result 1"
}()
select {
case res, ok := <-c1:
fmt.Println(res, ":", ok) // result 1 : true
case <-time.After(time.Second * 2):
fmt.Println("timeout 2")
}
}
package main
import "time"
import "fmt"
func main() {
c1 := make(chan string, 1)
ret := 0
go func() {
time.Sleep(time.Second * 1)
c1 <- "result 1"
}()
for {
select {
case res, ok := <-c1:
fmt.Println(res, ":", ok)
case <-time.After(time.Second * 2):
fmt.Println("timeout 2")
ret = 1
}
if ret == 1 {
break
}
}
close(c1)
}
for {
select {
case res, ok := <-c1:
fmt.Println(res, ":", ok)
case cur_time, ok := <-time.After(time.Second * 2):
fmt.Println("timeout: ", cur_time, ok)
ret = 1
}
}
result 1 : true
timeout: 2021-10-31 04:41:22.66984658 +0000 UTC m=+3.000522917 true
Timer和Ticker
关于时间的两个Channel。
timer是一个定时器，代表未来的一个单一事件，可以告诉timer你要等待多长时间，
它提供一个Channel，在将来的那个时间该 Channel 提供一个时间值。
该例子中，第二行会阻塞2秒钟左右的时间，直到时间到才会继续执行。
timer1 := time.NewTimer(time.Second * 2)
<-timer1.C
fmt.Println("Timer 1 expired")
当然如果只想单纯等待，可以用time.Sleep。
还可以用timer.Stop来停止计时器。
timer2 := time.NewTimer(time.Second)
go func() {
<-timer2.C
fmt.Println("Timer 2 expired")
}()
stop2 := timer2.Stop()
if stop2 {
fmt.Println("Timer 2 stopped")
}
ticker是一个定时触发的计时器，它会以一个间隔(interval)往Channel发送一个事件(当前时间)，
而Channel的接收者可以以固定的时间间隔从Channel中读取事件。
下面的例子中ticker每500毫秒触发一次，观察输出的时间。
ticker := time.NewTicker(time.Millisecond * 500)
go func() {
for t := range ticker.C {
fmt.Println("Tick at", t)
}
}()
类似timer, ticker也可以通过Stop方法来停止。
一旦它停止，接收者不再会从channel中接收数据了。
close
内建的close方法可以用来关闭channel。
总结一下channel关闭后sender的receiver操作。
如果channel c已经被关闭,继续往它发送数据会导致panic: send on closed channel:
import "time"
func main() {
go func() {
time.Sleep(time.Hour)
}()
c := make(chan int, 10)
c <- 1
c <- 2
close(c)
c <- 3
}
但是从这个关闭的channel中不但可以读取出已发送的数据，还可以不断的读取零值:
c := make(chan int, 10)
c <- 1
c <- 2
close(c)
fmt.Println(<-c) //1
fmt.Println(<-c) //2
fmt.Println(<-c) //0
fmt.Println(<-c) //0
但是如果通过range读取，channel关闭后for循环会跳出：
c := make(chan int, 10)
c <- 1
c <- 2
close(c)
for i := range c {
fmt.Println(i)
}
通过i, ok := <-c可以查看Channel的状态，判断值是零值还是正常读取的值。
如果 ok 是 false ，表明接收的 x 产生了零值，这个channel被关闭了或者为空。
c := make(chan int, 10)
close(c)
i, ok := <-c
fmt.Printf("%d, %t", i, ok) //0, false
同步
channel可以用在goroutine之间的同步。
main goroutine通过done channel等待worker完成任务。
worker做完任务后只需往channel发送一个数据就可以通知main goroutine任务完成。
import (
"fmt"
"time"
)
func worker(done chan bool) {
time.Sleep(time.Second)
// 通知任务已完成
done <- true
}
func main() {
done := make(chan bool, 1)
go worker(done)
// 等待任务完成
<-done
}