go channel

1
2

ChannelType = ( "chan" | "chan<-" | "<-chan" ) ElementType .

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

<-          // channel 的操作符
ch <- v     // 发送值 v 到 Channel ch 中
v := <-ch   // 从 Channel ch 中接收数据, 并将数据赋值给 v



var foo chan T          // 可以接收和发送类型为 T 的数据
var foo chan<- float64  // 只可以用来发送 float64 类型的数据
var foo <-chan int      // 只可以用来接收 int 类型的数据
// <- 总是优先和最左边的类型结合。(The <- operator associates with the leftmost chan possible)

chan<- chan int    // 等价 chan<- (chan int)
chan<- <-chan int  // 等价 chan<- (<-chan int)
<-chan <-chan int  // 等价 <-chan (<-chan int)
chan (<-chan int)

// channel 定义
var dataChan <-chan []byte

// 无缓冲的 channel
// 使用 make 初始化 Channel, 并且可以设置容量, channel 初始化, 初始化之后才能使用
// 未设置容量的 channel, 如果没有设置容量，或者容量设置为0, 说明Channel没有缓存，只有sender和receiver都准备好了后它们的通讯
// 无缓冲的 channel 由于没有缓冲发送和接收需要同步.
// channel 无缓冲时，发送阻塞直到数据被接收，接收阻塞直到读到数据。
dataChan := make(<-chan []byte)
// 容量为100的 channel
ch := make(chan int, 100)
// 容量(capacity)代表Channel容纳的最多的元素的数量，代表Channel的缓存的大小。

// 创建一个双向channel, interface{}表示chan可以为任何类型
foo := make(chan interface{})

// 可以通过内建的close方法可以关闭Channel。
close(foo)

// channel的 receive支持 multi-valued assignment，如
v, ok := <-ch

1
2
3
4
5
6

// 发送操作
ch <- x 
// 接收操作
x = <-ch 
// 忽略接收到的值，合法
<-ch     

1
2
3
4
5
6
7

// 创建 channel
make (chan type)
make (chan type,N) // 表示该channel自带N个type类型大小的buffer,只有该chan满/空时，调用方才会被阻塞
ch := make(chan int)

// 使用make初始化Channel,并且可以设置容量:
make(chan int, 100)

1
2
3

for i := range c {
        fmt.Println(i)
    }

1
2
3
4
5
6

// 上例中的 Handler.stopCh 就是一个例子，
// stopCh 并不需要传递任何数据, 只是要给所有协程发送退出的信号
type Handler struct {
    stopCh chan struct{}
    reqCh chan *Request
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package main

import (
    "time"
    "log"
)

var ch chan struct{} = make(chan struct{})

func foo() {
    ch <- struct{}{}
    log.Println("foo() 111");
    time.Sleep(5 * time.Second)
    log.Println("foo() 222");
    close(ch)
    log.Println("foo() 333");
}

func main() {

    log.Println("main() 111");
    go foo()
    log.Println("main() 222");
    <-ch
    log.Println("main() 333");
}