go语言之channel如何使用

1，Channel

Go语言的并发模型是CSP：
提倡通过通信共享内存而不是通过共享内存而实现通信

如果说goroutine是Go程序并发的执行体，channel就是它们之间的连接。channel是可以让一个goroutine发送特定值到另一个goroutine的通信机制。

Go语言中的通道（channel）是一种特殊的类型。通道像一个传送带或者队列，总是遵循先入先出的规则，保证收发数据的顺序。每一个通道都是一个具体类型的导管，也就是声明channel的时候需要为其指定元素类型.

2,声明channel

var 变量 chan 元素类型
例如：

var ch1 chan int    //声明一个传递整形的通道
var ch2 chan bool   //
var ch3 chan []int  //

3,创建channel

通道是引用类型的 通道类型的值是nil

var ch1 int
fmt.Println(ch1)  //nil

声明通道后 需要使用make 函数初始化之后才能使用。

创建channel的格式如下：

make(chan 元素类型，[缓冲大小])

channel的缓冲大小是可选的

ch4 := make(chan int)ch5 := make(chan bool)ch6 := make(chan []int)
ch4 := make(chan int,100)  //缓冲类型 int 大小 100个

4，channel的操作

通道有发送（send）、接收(receive）和关闭（close）三种操作
发送和接收都使用<-符号

发送:
将一个值发送到通道中。

   ch <- 10 // 把10发送到ch中

接收:
从一个通道中接收值。

x := <- ch	// 从ch中接收值并赋值给变量
x    <-ch       // 从ch中接收值，忽略结果

关闭:
我们通过调用内置的close函数来关闭通道。

    close(ch)

注意：

关闭通道需要注意的事情是，只有在通知接收方goroutine所有的数据都发送完毕的时候才需要关闭通道。

通道是可以被垃圾回收机制回收的，它和关闭文件是不一样的，在结束操作之后关闭文件是必须要做的，但关闭通道不是必须的。

关闭后的通道有以下特点

1.对一个关闭的通道再发送值就会导致panic。
2.对一个关闭的通道进行接收会一直获取值直到通道为空。
3.对一个关闭的并且没有值的通道执行接收操作会得到对应类型的零值。
4.关闭一个已经关闭的通道会导致panic。

5,无缓冲通道

使用无缓冲的通道 在goroutine之间同步

无缓冲的通道又称为阻塞的通道

func main() {
    ch := make(chan int)    
    ch <- 10    
    fmt.Println("发送成功")
}

上面的代码可以编过，但是运行就报以下错误

fatal error: all goroutines are asleep - deadlock!
    goroutine 1 [chan send]:    main.main() 
               .../src/mytest/main.go:8 +0x54            

为什么会发生 死锁的问题？

原因：

因为我们创建的是无缓冲通道，无缓冲 只有在有人接收值的时候才能发送值。

简单来说，无缓冲通道必须有接受才能发送。上面代码 阻塞在 ch<-10 这一行形成死锁。

func recv(c chan int) {
    ret := <-c    
    fmt.Println("接收成功", ret)
}

func main() {    
	ch := make(chan int)    
	go recv(ch) // 启用goroutine从通道接收值    
	ch <- 10    
	fmt.Println("发送成功")
}

无缓冲通道上的发送操作会阻塞，直到另一个goroutine在该通道上执行接收操作，这时值才能发送成功两个goroutine将继续执行。

相反，如果接收操作先执行，接收方的goroutine将阻塞，直到另一个goroutine在该通道上发送一个值。

使用无缓冲通道进行通信将导致发送和接收的goroutine同步化。

因此，无缓冲通道也被称为同步通道

6，有缓冲的通道

使用有缓冲的通道在goroutine之间同步数据

使用make函数初始化通道的时候为其指定通道的容量

func main() {
    ch := make(chan int, 1) // 创建一个容量为1的有缓冲区通道    
    ch <- 10    
    fmt.Println("发送成功")
}

只要通道的容量大于零，那么该通道就是有缓冲的通道

通道的容量表示通道中能存放元素的数量。就像你小区的快递柜只有那么个多格子，格子满了就装不下了，就阻塞了，等到别人取走一个快递员就能往里面放一个。

我们可以使用内置的len函数获取通道内元素的数量，使用cap函数获取通道的容量，虽然我们很少会这么做。

7,close()

通过内置的close() 函数关闭channel

如果彼得通道不往里面 存/取 值的时候记得关闭通道

package main

import "fmt"

func main() {

    c := make(chan int)        
    go func() {        
    	for i := 0; i < 5; i++ {            
    		c <- i        
    	} 	        
       close(c)
    }()
            
    for {        
    	 if data, ok := <-c; ok {            
    	   fmt.Println(data)        
    	 } else {
                break
         }  
    }      
    
    fmt.Println("main结束")
}

8,如何优雅的从通道循环取值

当通过通道发送有限的数据时，我们可以通过close函数关闭通道来告知从该通道接收值的goroutine停止等待。

当通道被关闭时，往该通道发送值会引发panic，从该通道里接收的值一直都是类型零值。

那如何判断一个通道是否被关闭了呢？

func main() {
    ch1 := make(chan int)    
    ch2 := make(chan int)    // 开启goroutine将0~100的数发送到ch1中    
    go func() {        
   	 for i := 0; i < 100; i++ {           
     		ch1 <- i     
        }        
        close(ch1)   
     }()        
     
	// 开启goroutine从ch1中接收值，并将该值的平方发送到ch2中    
	go func() {       
		 for {         
   			 i, ok := <-ch1 // 通道关闭后再取值ok=false         
      			 if !ok {             
          			break      
                 	}          
                 	ch2 <- i * i      
          	}     
          	close(ch2)   
	}()       
	
      // 在主goroutine中从ch2中接收值打印 
     for i := range ch2 { // 通道关闭后会退出for range循环        
                  fmt.Println(i)    
      }   
}

我们看到有两种方式在接收值的时候判断通道是否被关闭，我们通常使用的是for range的方式。

9, 单项通道

有的时候我们会将通道作为参数在多个任务函数间传递，很多时候我们在不同的任务函数中使用通道都会对其进行限制，比如限制通道在函数中只能发送或只能接收。

Go语言中提供了单向通道来处理这种情况

//往函数参数里面写数据，写完关闭通道(通道是引用类型的当然可以这么做)
func counter(out chan<- int) {
    for i := 0; i < 100; i++ {
       out <- i
    }
    close(out)
}

func squarer(out chan<- int, in <-chan int) { 
   for i := range in {        
   	out <- i * i    
   }    
   
   close(out)
}

func printer(in <-chan int) {
    for i := range in {        
    fmt.Println(i)    
    }
}

func main() {    
	ch1 := make(chan int)    
	ch2 := make(chan int)        
	go counter(ch1)    
	go squarer(ch2, ch1)        
	printer(ch2)
}

注意：

1.chan<- int是一个只能发送的通道，可以发送但是不能接收；    
2.<-chan int是一个只能接收的通道，可以接收但是不能发送。