1、channel概述

Go的CSP并发模型，是通过 goroutine 和 channel 来实现的。

• channel 是Go语言中各个并发结构体( goroutine )之前的通信机制。 通俗的讲，就是各个 goroutine 之间通信的”管道“，有点类似于Linux中的管道。
• Go并发的核心哲学是不要通过共享内存进行通信; 相反，通过沟通分享记忆。

channel是Go提供goroutine间的通信方式，使用channel可以使多个goroutine之间通信。 channel是进程内的通信方式 ，通过channel传递对象的过程和调用函数时的参数传递行为比较一致，比如也可以传递指针等。

如需跨进程通信，Go建议用分布式系统的方法来解决，如使用Socket或者HTTP等通信协议，Go语言在网络方面也有非常完善的支持。

主要应用场景：

• 数据交流：当作并发的 buffer 或者 queue，解决生产者 - 消费者问题。多个 goroutine 可以并发当作生产者（Producer）和消费者（Consumer）。
• 数据传递：一个goroutine将数据交给另一个goroutine，相当于把数据的拥有权托付出去。
• 信号通知：一个goroutine可以将信号(closing，closed，data ready等)传递给另一个或者另一组goroutine。
• 任务编排：可以让一组goroutine按照一定的顺序并发或者串行的执行，这就是编排功能。
• 锁机制：利用channel实现互斥机制。

2、channel基本语法

每个channel都有一个特殊的类型，也就是channels可发送数据的类型。一个可以发送int类型数据的channel一般写为chan int。
声明通道 ：var 通道变量 chan 通道类型：var channame chan ElementType
创建通道 ：make（chan 数据类型, [缓冲大小]）：

channel跟map类似的在使用之前都需要使用make进行初始化
ch1 := make(chan int, 5)

未初始化的channel零值默认为nil， 是一种特殊的 chan，对值是 nil 的 chan 的发送接收调用者总是会阻塞。

var ch chan int
fmt.Println(ch) // <nil>

channel的基本用法非常简单，它提供了三种类型，分别为只能接收，只能发送，既能接收也能发送这三种类型：
var channame chan <- ElementType //只写：只能发送ElementType
var channame <- chan ElementType //只读：只能从chan里接收ElementType

var channame chan ElementType //能读能写：既能接收也能发送

我们把既能发送也能接收的chan被称为 双向chan ，把只能接收或者只能发送的 chan称为单向 。

而对于close方法只能是发送通道拥有。

箭头总是射向左边的，元素类型总在最右边。

如果箭头指向 chan，就表示可以往 chan 中发送(写)数据；

如果箭头远离 chan，就表示 chan 会往外吐数据，即能从 chan里接收(读)数据

channel <- 1 //向channel添加一个值为1
<- channel //从channel取出一个值
a := <- channel //从channel取出一个值并赋值给a
a,b := <- channel //从channel取出一个值赋值给a，如果channel已经关闭或channel没有值，b为false

3、通信机制：

• 成对出现： 在通信过程中，传数据 channel <- data 和取数据 <-channel 必然会成对出现 ，因为这边传，那边取，两个 goroutine 之间才会实现通信。
• 阻塞： 不管传还是取，必阻塞，直到另外的 goroutine 传或者取为止。
• channel仅允许被一个goroutine读写。

3）同步，主协程和子协程之间通信：

func main(){
    ch := make(chan int)
    go func() {
        ch <- 996 //向ch添加元素
    a := <- ch
    fmt.Println(a)
    fmt.Println("程序结束！")
4)、两个子协程的通信
 
使用channel实现两个goroutine之间通信。
 
func two() {
    tc := make(chan string)
    ch := make(chan int)
    // 第一个协程
    go func() {
        tc <- "协程A，我在添加数据"
        ch <- 1
    // 第二个协程
    go func() {
        content := <- tc
        fmt.Printf("协程B，我在读取数据:%s\n",content)
        ch <- 2
    fmt.Println("程序结素！")
func main(){
    two()
5）、channel仅允许被一个goroutine读写。
 
package main
import (
    "fmt"
    "time"
func goRoutineA(a <-chan int) {
    val := <-a
    fmt.Println("goRoutineA received the data", val)
func goRoutineB(b chan int) {
    val := <-b
    fmt.Println("goRoutineB  received the data", val)
func main() {
    ch := make(chan int, 3)
    go goRoutineA(ch)
    go goRoutineB(ch)
    ch <- 3
    time.Sleep(time.Second * 1)
6)、一直阻塞的情况
 
如果当前协程正在从一个没有任何值的通道中读取数据，那么当前协程会阻塞并且等待其他协程往此通道写入值。
因此，读操作将被阻塞。类似的，如果你发送数据到一个通道，它将阻塞当前协程直到有其他协程从通道中读取数据。此时写操作将阻塞 。
 
主线程在进行通道操作的时候造成死锁：
 
package main
import "fmt"
func main() {
	fmt.Println("mainGo start")
	channel := make(chan string)
   // 给通道 channel 传入一个数据GoLang.
	channel <- "GoLang"
	//此时主线程将阻塞直到有协程接收这个数据. Go的调度器开始调度协程接收通道 channel 的数据
	// 但是由于没有协程接受，没有协程是可被调度的。所有协程都进入休眠状态，即是主程序阻塞了。
	fmt.Println("mainGo stop")
mainGo go start
fatal error: all goroutines are asleep - deadlock!  //所有协程都进入休眠状态,死锁
goroutine 1 [chan send]:
main.main()
如果想要运行成功那么在发送信息前就应该有另外的协程等待着接收：
 
package main
import "fmt"
func main() {
   fmt.Println("mainGo start")
   channel := make(chan string)
   go receive(channel)
   // 给通道 channel 传入一个数据GoLang.
   channel <- "GoLang"
   //此时主线程将阻塞直到有协程接收这个数据. Go的调度器开始调度协程接收通道 channel 的数据
   // 但是由于有receive子协程接受，主程序可以继续执行。
   fmt.Println("mainGo stop")
func receive(ch1 chan string) {
   for {
      select {
      case rec2 := <-ch1:
         fmt.Println("channel被接受，程序结束:rec:,", rec2)
   fmt.Println("mainGo stop")
4、channel缓冲区
 
c := make(chan Type, n)
 
当缓冲区参数不是 0 的时候。协程将不会阻塞除非缓冲区被填满。
 
无缓冲通道，make(chan int)，指在接收前没有能力保存任何值的通道，这种类型的通道要求发送goroutine和接收goroutine同时准备好，才能完成发送和接收操作。
有缓冲通道，make(chan int, 2)，指在被接收前能存储一个或者多个值的通道，这种类型的通道并不强制要求goroutine之间必须同时完成发送和接收。
 
 
 当缓冲区满了之后，想要再往缓冲区写数据只有等到有其他协程从缓冲区读完数据， 此时的发送协程是阻塞的。
读缓冲区的操作是渴望式读取，意味着一旦读操作开始它将读取缓冲区所有数据，直到缓冲区为空。
原理上来说读操作的协程将不会阻塞直到缓冲区为空。
 
由于channel没有缓冲区，一直阻塞的情况已经提到了。
 
但是如果有缓冲区就能避免程序阻塞，可以将发送的channel放在缓冲区直至有接收方将它接收：
 
package main
import "fmt"
func main() {
	fmt.Println("mainGo start")
	channel := make(chan string, 1)
	// 给通道 channel 传入一个数据GoLang.
	channel <- "GoLang"
	//由于有缓冲区此时主线程将不会阻塞，可以继续运行
	fmt.Println("mainGo stop")
mainGo start
mainGo stop
增加协程读取：
 
package main
import "fmt"
func main() {
	fmt.Println("mainGo start")
	channel := make(chan string, 1)
    //协程读取缓冲通道，由于没有阻塞，子协程receive几乎不会得到执行
	go receive(channel)
	// 给通道 channel 传入一个数据GoLang.
	channel <- "GoLang"
	fmt.Println("mainGo stop")
func receive(c chan string) {
	for {
		val, _ := <-c
		fmt.Println("channel的结果:" + val)
mainGo start
mainGo stop
向channel添加数据超过缓存，会出现死锁：
 
package main
import "fmt"
func main() {
	fmt.Println("mainGo start")
	channel := make(chan string, 1)
	// 给通道 channel 传入一个数据GoLang.
	channel <- "GoLang"
	channel <- "GoLang2"
	//当加多一个channel <- GoLang2的时候，这时就要等缓冲区空了，也就是等有协程把GoLang读取完，所以就会导致主线程阻塞
	fmt.Println("mainGo stop")
mainGo start
fatal error: all goroutines are asleep - deadlock!
 虽然关闭了通道，但是其实数据不仅在通道里面，数据还在缓冲区中的，我们依然可以读取到这个数据。
 
package main
import "fmt"
func main() {
	c := make(chan int, 3)
	c <- 1
	c <- 2
	c <- 3
	close(c)
	for elem := range c {
		fmt.Println(elem)
5、单向通道
 
也可以创建单向通道。比如只读通道只允许读操作，只写通道只允许写操作。
 
单向通道也可以使用 make 函数创建，不过需要额外加一个箭头语法。
 
roc := make(<-chan int)
soc := make(chan<- int)
 
单向通道的目的：提高程序的类型安全性， 使得程序不容易出错。例如函数参数是单通道，则此函数只能对通道进行写入或者读取。这样就限制了函数对通道的滥用。如果入参通道是双向通道，那么函数对单向通道的修改不会影响函数外部对双向通道的使用。
 
1）只能接收数据的chan
 
package main 
import "fmt"
// a 表示只能接收数据的chan
func goChanA(a <-chan int) {
  b := <-a
  fmt.Println("只能接收数据的channal[a]接收到的数据值为", b)
func main() {
  ch := make(chan int, 2)
  go goChanA(ch)
  // 往ch中写入数据值
  ch <- 2
  time.Sleep(time.Second)
结果：只能接收数据的channal[a]接收到的数据值为 2
 
2）只能发送数据的chan
 
package main 
import "fmt
func main() {
  ch := make(chan<- int, 2)
  ch <- 200
往 chan 中发送一个数据使用“ch<-”。
 这里的 ch 是 chan int 类型或者是 chan <-int。
 
6、 阻塞的 gorutinue 与资源泄露
 
在 2012 年 Google I/O 大会上，Rob Pike 的 Go Concurrency Patterns 演讲讨论 Go 的几种基本并发模式，如 完整代码 中从数据集中获取第一条数据的函数：
 
    func First(query string, replicas []Search) Result {
        c := make(chan Result)
        replicaSearch := func(i int) { c <- replicas[i](query) }
        for i := range replicas {
            go replicaSearch(i)
        return <-c
在搜索重复时依旧每次都起一个 goroutine 去处理，每个 goroutine 都把它的搜索结果发送到结果 channel 中，channel 中收到的第一条数据会直接返回。
 
返回完第一条数据后，其他 goroutine 的搜索结果怎么处理？他们自己的协程如何处理？
 
在 First() 中的结果 channel 是无缓冲的，这意味着只有第一个 goroutine 能返回，由于没有 receiver，其他的 goroutine 会在发送上一直阻塞。如果你大量调用，则可能造成资源泄露。
 
为避免泄露，你应该确保所有的 goroutine 都能正确退出，有 2 个解决方法：
 
    使用带缓冲的 channel，确保能接收全部 goroutine 的返回结果：
 
func First(query string, replicas ...Search) Result {  
        c := make(chan Result,len(replicas))    
        searchReplica := func(i int) { c <- replicas[i](query) }
        for i := range replicas {
            go searchReplica(i)
        return <-c
使用 select 语句，配合能保存一个缓冲值的 channel default 语句：
 
default 的缓冲 channel 保证了即使结果 channel 收不到数据，也不会阻塞 goroutine
 
    func First(query string, replicas ...Search) Result {  
        c := make(chan Result,1)
        searchReplica := func(i int) {
            select {
            case c <- replicas[i](query):
            default:
        for i := range replicas {
            go searchReplica(i)
        return <-c
    使用特殊的废弃（cancellation） channel 来中断剩余 goroutine 的执行：
 
func First(query string, replicas ...Search) Result {  
        c := make(chan Result)
        done := make(chan struct{})
        defer close(done)
        searchReplica := func(i int) {
            select {
            case c <- replicas[i](query):
            case <- done:
        for i := range replicas {
            go searchReplica(i)
        return <-c
Rob Pike 为了简化演示，没有提及演讲代码中存在的这些问题。不过对于新手来说，可能会不加思考直接使用。
 
 二、使用Select来进行调度
 
1、select概述
 
select就是用来监听和channel有关的IO操作，当 IO 操作发生时，触发相应的动作。
 
Select 和 swith结构很像，但是select中的case的条件只能是I/O。
 
 
Select 的使用方式类似于 switch 语句，它也有一系列 case 分支和一个默认的分支。
 每个 case分支会对应一个通道的通信（接收或发送）过程。select 会一直等待，直到其中的某个 case 的通信操作完成时，就会执行该 case分支对应的语句。
 
具体格式如下：
 
select {
case <-ch1:
	//...
case rec := <-ch2:
	//...
case ch3 <- 10:
	//...
default:
	//默认操作
select里面case是随机执行的，如果都不满足条件，那么就执行default
 
select总结：
 
每个case必须是一个I/O操作
case是随机执行的：如果多个 case 同时满足，select 会随机选择一个执行。
如果所有case不能执行，那么会执行default
如果所有case不能执行，且没有default，会出现阻塞，一旦某个 case 条件执行，它将不阻塞。
对于没有 case 的 select 会一直阻塞，可用于阻塞 main 函数，防止退出
 
2、实现一个一直接收消息
 
实现一个一直接收消息：
 
func main() {
	ch := make(chan int)
	for i := 1; i <= 10; i++ {
		go func(j int) {
			ch <- j
	for {
		select {
		case a1 := <- ch:
			fmt.Println(a1)
		default:
2、演示select case选择机制
 
package main
import (
	"fmt"
	"time"
func goRoutine1(ch chan int, i int) {
	time.Sleep(time.Second * 3)
	ch <- i
func goRoutine2(chs chan string, i string) {
	time.Sleep(time.Second * 3)
	chs <- i
func main() {
	ch1 := make(chan int, 5)
	ch2 := make(chan string, 5)
	go goRoutine1(ch1, 5)
	go goRoutine2(ch2, "ok")
	select {
	case msg1 := <-ch1:
		fmt.Println(" received the data1 ", msg1)
	case msg2 := <-ch2:
		fmt.Println(" received the data2 ", msg2)
	default:
		fmt.Println("no data received ")
		time.Sleep(time.Second * 1)
1）选择default的情况：
 
因为当前时间没有到3s，即所有case不能执行，那么会执行default，所以select 选择defult。
 
运行结果：
 
no data received
 
2）随机选择case
 
修改程序，我们注释掉default
 
 并多执行几次结果，每次结果都不是固定的：
 
received the data1 5
 
received the data2 ok
 
received the data2 ok
 
received the data2 ok
 
select语句会阻塞，直到监测到一个可以执行的IO操作为止，而这里goRoutine1和goRoutine2睡眠时间是相同的，都是3s，从输出可看出，从channel中读出数据的顺序是随机的。
 
3）选择符合条件的case
 
再修改代码，goRoutine1睡眠时间改成4s
 
func goRoutine1(ch chan int, i int) {
   time.Sleep(time.Second * 4)
   ch <- i
此时会先执行goRoutine2，select 选择case msg2 := <-ch2
 
 
上述程序模拟了一个数个请求的服务器负载均衡的例子，它从多个有效服务中返回其中一个响应。
 使用协程，通道和 select 语句，我们可以向多个服务器请求数据并获取其中最快响应的那个。
 
三、死锁（deadlock）情况
 
指两个或两个以上的协程的执行过程中，由于竞争资源或由于彼此通信而造成的一种阻塞的现象。
 
在非缓冲信道若发生只流入不流出，或只流出不流入，就会发生死锁。
 
下面是一些死锁的例子
 
1、向非缓冲通道写数据会发生阻塞，导致死锁
 
package main
func main() {
   ch := make(chan int)
   ch <- 3
上面情况，向非缓冲通道写数据会发生阻塞，导致死锁。解决办法创建缓冲区 ch := make(chan int，3)
 
2、向非缓冲通道读取数据会发生阻塞，导致死锁
 
package main
import (
   "fmt"
func main() {
   ch := make(chan int)
   fmt.Println(<-ch)
向非缓冲通道读取数据会发生阻塞，导致死锁。 解决办法开启缓冲区，先向channel写入数据。
 
package main
func main() {
   ch := make(chan int, 3)
   ch <- 3
   ch <- 4
   ch <- 5
   ch <- 6
3、写入数据超过缓冲区数量也会发生死锁
 
写入数据超过缓冲区数量也会发生死锁。
 
解决办法将写入数据取走。
 
4、如果select的所有case不能执行，且没有default，会出现阻塞
 
解决办法select增加default块，
 
   select的default 块在通道操作阻塞的时候是非常有用的，他可以避免死锁。 同时由于 default块的非阻塞特性，Go 可以避免在其他协程阻塞的时候去调度其他协程，从而避免死锁。
 通道的发送操作也类似，， default 可以在其他协程不能被调度的时候被执行，从而避免死锁。
 
5、产生panic的情况
 
还有一种情况，向关闭的channel写入数据，不会产生死锁，产生panic。
 
package main
func main() {
	ch := make(chan int, 3)
	ch <- 1
	close(ch)
	ch <- 2
四、channel实现原理 
 
1、channel数据结构
 
channel一个类型管道，通过它可以在goroutine之间发送消息和接收消息。它是golang在语言层面提供的goroutine间的通信方式。通过源代码分析程序执行过程，源码src/runtime/chan.go：
 
channel结构体hchan：
 
type hchan struct {
  qcount uint          // 当前队列列中剩余元素个数
  dataqsiz uint        // 环形队列长度，即可以存放的元素个数即缓冲区的大小，即make（chan T，N），N.
  buf unsafe.Pointer   // 环形队列列指针
  elemsize uint16      // 每个元素的⼤⼩
  closed uint32        // 标识关闭状态：表示当前通道是否处于关闭状态。创建通道后，该字段设置为0，即通道打开; 通过调用close将其设置为1，通道关闭。
  elemtype *_type      // 元素类型：用于数据传递过程中的赋值；
  sendx uint           // 队列下标，指示元素写⼊入时存放到队列列中的位置 x
  recvx uint           // 队列下标，指示元素从队列列的该位置读出  
  recvq waitq          // 等待读消息的goroutine队列
  sendq  waitq         // 等待写消息的goroutine队列
  lock mutex           // 互斥锁，chan不允许并发读写
type waitq struct {
	first *sudog
	last  *sudog
从数据结构可以看出channel由队列、类型信息、goroutine等待队列组成。
 
2、实现方式
 
创建channel 有两种，一种是带缓冲的channel，一种是不带缓冲的channel
 
// 带缓冲
ch := make(chan Task, 6)
// 不带缓冲
ch := make(chan int)
 
下图展示了可缓存6个元素的channel底层的数据模型如下图：
 
func makechan(t *chantype, size int) *hchan {
   elem := t.elem
dataqsiz：指向队列的长度为6，即可缓存6个元素
buf：指向队列的内存，队列中还剩余两个元素
qcount：当前队列中剩余的元素个数
sendx：指后续写入元素的位置
recvx：指从该位置读取数据
 
从channel中读数据，如果channel缓冲区为空或者没有缓冲区，当前goroutine会被阻塞；向channel中写数据，如果channel缓冲区已满或者没有缓冲区，当前goroutine会被阻塞。
 
被阻塞的goroutine将会被挂在channel的等待队列中：
 
因读阻塞的goroutine会被向channel写入数据的goroutine唤醒
因写阻塞的goroutine会被从channel读数据的goroutine唤醒
 
下面展示了一个没有缓冲区的channel，有几个goroutine阻塞等待数据：
 
注意，一般情况下recvq和sendq至少有一个为空。只有一个例外，那就是同一个goroutine使用select语句向channel一边写数据一边读数据。
 
3、向channel写数据
 
ch := make(chan int, 3)
 
创建通道后的缓冲通道结构：
 
hchan struct {
	qcount uint : 0 
	dataqsiz uint : 3 
	buf unsafe.Pointer : 0xc00007e0e0 
	elemsize uint16 : 8 
	closed uint32 : 0 
	elemtype *runtime._type : &{
		size:8 
		ptrdata:0 
		hash:4149441018 
		tflag:7 
		align:8 
		fieldalign:8 
		kind:130 
		alg:0x55cdf0 
		gcdata:0x4d61b4 
		str:1055 
		ptrToThis:45152
	sendx uint : 0 
	recvx uint : 0 
	recvq runtime.waitq : 
		{first:<nil> last:<nil>}
	sendq runtime.waitq : 
		{first:<nil> last:<nil>}
	lock runtime.mutex : 
		{key:0}
 写入数据：ch <- 3，底层hchan数据流程如图
 
 1、锁定整个通道结构。
 
2、确定写入：如果recvq队列不为空，说明缓冲区没有数据或者没有缓冲区，此时直接从recvq等待队列中取出一个G（goroutine），并把数据写入，最后把该G唤醒，结束发送过程；
 
3、如果recvq为Empty，则确定缓冲区是否可用。如果可用，从当前goroutine复制数据写入缓冲区，结束发送过程。
 
4、如果缓冲区已满，则要写入的元素将保存在当前正在执行的goroutine的结构中，并且当前goroutine将在sendq中排队并从运行时挂起（进入休眠，等待被读goroutine唤醒）。
 
5、写入完成释放锁。
 
这里我们要注意几个属性buf、sendx、lock的变化。
 
4、从channel读取操作
 
几乎和写入操作相同
 
func goRoutineA(a <-chan int) {
   val := <-a
   fmt.Println("goRoutineA received the data", val)
底层hchan数据流程如图：
 
1、先获取channel全局锁
 
2、如果等待发送队列sendq不为空（有等待的goroutine）：
 
       1）若没有缓冲区，直接从sendq队列中取出G（goroutine），直接取出goroutine并读取数据，然后唤醒这个goroutine，结束读取释放锁，结束读取过程；
 
       2）若有缓冲区（说明此时缓冲区已满），从缓冲队列中首部读取数据，再从sendq等待发送队列中取出G，把G中的数据写入缓冲区buf队尾，结束读取释放锁；
 
3、如果等待发送队列sendq为空（没有等待的goroutine）：
 
      1）若缓冲区有数据，直接读取缓冲区数据，结束读取释放锁。
 
      2）没有缓冲区或缓冲区为空，将当前的goroutine加入recvq排队，进入睡眠，等待被写goroutine唤醒。结束读取释放锁。
 
ecvq和
 
recvq和sendq 结构
 
recvq和sendq基本上是链表，看起来基本如下：
 
                    Go的并发模型已经在详细说明。Go的CSP并发模型，是通过goroutine和channel来实现的。channelgoroutinegoroutinechannel是Go提供goroutine间的通信方式，使用channel可以使多个goroutine之间通信。，通过channel传递对象的过程和调用函数时的参数传递行为比较一致，比如也可以传递指针等。channel是类型相关的，一个channel只能传递一种类型的值，这个类型需要在声 明channel时指定。
WebRTC数据通道的简单示例。 使用替代实际的信令通道。
 我之所以这样做，是因为我对缺乏良好的WebRTC数据频道示例和在线教程感到沮丧。
 在侧面遵循MDN时，该代码应该是不言自明的。 只有一个陷阱，它已被记录/注释。 遵循开发人员工具中的控制台消息后，应该可以清楚地了解发生的情况和时间。
提供者-应答者模式
Unix： open offerer-answerer/index.html
 Windows： start offerer-answerer/index.html
 Chrome测试： ./cmd/chrome-screenshot/cmd.sh offerer-answerer
 Firefox测试： ./cmd/firefox-screenshot/cmd.sh offerer-answerer
 在此演示中，提供者和应答者有两个单独的文件，以便
				
文章目录超时处理非阻塞通道操作通道的关闭通道遍历
超时对于一个连接外部资源，或者其它一些需要花费执行时间的操作的程序而言是很重要的。得益于通道和 select，在 Go 中实现超时操作是简洁而优雅的。
package main
import "time"
import "fmt"
func main() {
    // 在我们的例子中，假如我们执行一个外部调用，并在 2 秒后
    // 通过通道 `c1` 返回它的执行结果。
    c1 := make(chan string, 1)
				
1、goroutine
Golang 在语言层面对并发编程提供支持，一种类似协程，称作 goroutine 的机制。
只需在函数调用语句前添加 go 关键字，就可创建并发执行单元。开发人员无需了解任何执行细节，调度器会自动将其安排到合适的系统线程上执行。goroutine 是一种非常轻量级的实现，可在单个进程里执行成千上万的并发任务。
事实上，入口函数 main 就以 goroutine 运行。另...
				
channel类型
这是go里面的核心数据类型，有了它我们可以方便的进行协程间数据通信。其原理来源于csp模型理论，go实现了部分理论。
简单说，csp模型由并发执行的实体（如进程或线程）组成，实体之间通过发消息进行通信，其中channel承担了实体和实体之间发送消息的通道。
在go里面goroutine就是实体，它里面也有个channel来完成通信。
// 定义一个函数
func sum(num...
				
无缓冲区channel
用make(chan int) 创建的chan, 是无缓冲区的, send 数据到chan 时，在没有协程取出数据的情况下， 会阻塞当前协程的运行。ch <- 后面的代码就不会再运行，直到channel 的数据被接收，当前协程才会继续往下执行。
			ch := make(chan int) // 创建无缓冲channel
content := make([]byte,3) //只能读三个字节，最后打印的是字符串对应于int的值，初始化为3个0值
fmt.Println(file.Read(content))
fmt.Println(len(content),cap(content),content,string(content))//字节转化为字符使用string()
3 读取了