前面介绍了goroutine的用法，如果有多个goroutine的话相互之间是如何传递数据和通信的呢。在C语言或者JAVA中，传输的方法包括共享内存，管道，信号。而在Go语言中，有了更方便的方法，就是channel。在同一时刻，仅有一个goroutine能向一个通道发送元素值，同时也仅有一个goroutine能从它那里接收元素值。在通道中，各个元素值都是严格按照发送到此的先后顺序排列的，最早被发送到通道的元素会最新被接收。因此通道相当于一个FIFO的队列。而且通道的元素也具有原子性，是不可被分割的。通道中的每一个元素值都只能被某一个goroutine接收，已被接收的的元素值会立刻从通道中删除。
channel的类型表示法：采用chan关键字
type intchan chan int
var intchan chan int
上面两种声明表示一个chan int类型的变量。初始化后，变量intchan就可以用来传递int类型的元素值了。那么如何从通道中发送数据以及接收数据呢。Channel中采用<- 以及->符号
<- intchan就表示从intchan中发送一个数据。intchan <- 就表示intchan接收一个数据
初始化通道
make(chan int,10)
这个表达式初始化了一个通道类型的值，传递给make函数的第一个参数表明，此值的具体类型是元素类型为int的通道类型。而第二个参数则指出该通道在同一时刻最多可以缓存10个元素值。当然，也可以在初始化一个通道的时候省略第二参数值，比如make(chan int)。如果第二个参数被忽略了，表示被初始化的这个通道永远无法缓存任何元素值，发送给它的元素值应该被立刻取走，否则发送发的goroutine就会被暂停，直到有接收方接收这个元素值。第二个参数大于0的可以称为缓冲通道，等于0的可以称为非缓冲通道。
strChan:=make(chan string,3)
如果要从这个通道中接收值，那么应该这样写代码 elem:=<-strChan。或者是elem,ok:=<-strChan。Ok是一个布尔变量值，赋值成功为true，失败为false
但是注意如果通道中没有任何元素时，当前的goroutine会被阻塞在此。如果在进行接收操作之前或过程当中该通道被关闭了。那么该操作会立即结束。并且变量elem会被赋予该通道的元素类型的零值。
来看一个使用channel的例子：代码如下
var strChan=make(chan string,3)
func main(){
synChan1:=make(chan struct{},1)
synChan2:=make(chan struct{},2)
go func(){
<-synChan1
fmt.Println("Received a sync signal and wait a second...[receiver]")
time.Sleep(time.Second)
for{
if elem,ok:=<-strChan;ok {
fmt.Println("Received:", elem, "[receiver]")
}else{
break
}
}
fmt.Println("Stopped.[receiver]")
synChan2 <- struct{}{}
}()
go func(){
for _,elem:=range[]string{"a","b","c","d"}{
strChan <- elem
fmt.Println("Sent:",elem,"[Sender]")
if elem == "c"{
synChan1 <- struct{}{}
fmt.Println("Sent a sync signal.[sender]")
}
}
fmt.Println("Wait for 2 seconds")
time.Sleep(time.Second*2)
close(strChan)
synChan2 <- struct{}{}
}()
<-synChan2
<-synChan2
}
运行结果如下：
Sent: a [Sender]
Sent: b [Sender]
Sent: c [Sender]
Sent a sync signal.[sender]
Received a sync signal and wait a second...[receiver]
Sent: d [Sender]
Wait for 2 seconds
Received: a [receiver]
Received: b [receiver]
Received: c [receiver]
Received: d [receiver]
Stopped.[receiver]
在这个例子中，先后启用了两个goroutine。分别用于演示在strChan之上的发送和接收操作。
发送操作的go函数：for循环中用于把切片的4个元素依次发送给strChan。当发送完第三个的时候，向synChan1发送了一个信号。这个信号会使接收方接收到后恢复执行。当for循环结束后，让当前的goroutine睡眠了2秒。这是为了等待接收方将4个值都接收完。再调用close关闭strChan通道。
接收操作的go函数：在synChan1收到信号前一直等待，当收到信号则恢复，说明strChan中已经有了3个元素。不过先睡眠1秒钟再去读。这是因为strChan的容量是3，所以发送方在这1秒内发送第4个值时会因strChan已满而等待。直到接收方从strChan取出一个值。发送方在关闭strChan后，接收方取不到正确的值，则退出循环
整个流程图可以参考下图
另外synChan2，这个channel的作用是为了不让主goroutine过早结束运行。只有在接收方和发送方都执行完了之后，synChan2才会有2个值在里面。
当接收方从通道接收到一个值类型的值时，对该值的修改就不会影响到发送发持有的那个值。但对于引用类型的值来说，这种修改会同时影响收发双方持有的值。看下面的例子
var mapChan=make(chan map[string]int,1)
func main(){
synChan:=make(chan struct{},2)
go func(){
for{
if elem,ok := <-mapChan;ok{
elem["count"]++
}else{
break
}
}
fmt.Println("stopped.[receiver]")
synChan <- struct{}{}
}()
go func(){
countMap:=make(map[string]int)
for i:=0;i<5;i++{
mapChan <- countMap
time.Sleep(time.Millisecond)
fmt.Println("The count map:%v.[sender] ",countMap)
}
close(mapChan)
synChan <- struct{}{}
}()
<-synChan
<-synChan
}
运行结果：
The count map:.[sender] map[count:1]
The count map:.[sender] map[count:2]
The count map:.[sender] map[count:3]
The count map:.[sender] map[count:4]
The count map:.[sender] map[count:5]
stopped.[receiver]