【go语言学习】通道channel

通道channel被认为是goroutine通信的管道。类似于水管里的水可以从一端流向另一端，数据可以从一端发送到另一端，通过通道接收。

当多个goroutine间想实现共享数据时，可以使用传统的同步机制（sync包的方法），但是go语言强烈建议使用channel通道来实现goroutine之间的通信。

“不要通过共享内存来通信，而应该通过通信来共享内存”这是一句风靡golang社区的经典语言。

Go语言中，要传递某个数据给另一个goroutine(协程)，可以把这个数据封装成一个对象，然后把这个对象的指针传入某个channel中，另外一个goroutine从这个channel中读出这个指针，并处理其指向的内存对象。Go从语言层面保证同一个时间只有一个goroutine能够访问channel里面的数据，为开发者提供了一种优雅简单的工具，所以Go的做法就是使用channel来通信，通过通信来传递内存数据，使得内存数据在不同的goroutine中传递，而不是使用共享内存来通信。

一、什么是通道

1、通道的概念

通道是什么，通道就是goroutine之间的通道。它可以让goroutine之间相互通信。

每个通道都有与其相关的类型。该类型是通道允许传输的数据类型。

通道的零值为nil。nil通道没有任何用处，因此通道必须使用类似于map和切片的方法来定义。

2、通道的声明

声明通道，和声明变量是一样的

// 声明通道
var 通道名称 chan 数据类型
// 初始化
通道名称 = make(chan 数据类型）

示例代码：

package main

import "fmt"

func main() {
    var c chan int
    if c == nil {
        fmt.Println("c声明但是没有初始化，是nil")
        c = make(chan int)
        fmt.Println(c == nil)
        fmt.Printf("%T", c)
    }
}

运行结果

c声明但是没有初始化，是nil
false
chan int

也可以用简短定义的方式声明通道

通道名称 := make(chan 数据类型）

3、通道数据类型

channel是引用类型的数据，在作为参数传递时， 传递的是内存地址。

package main

import "fmt"

func main() {
    c := make(chan int)
    fmt.Printf("main：%T, %p\n", c, c)
    test(c)
}

func test(c chan int) {
    fmt.Printf("test：%T, %p\n", c, c)
}

运行结果

main：chan int, 0xc00001a0c0
test：chan int, 0xc00001a0c0

二、channel的使用

1、发送和接收

发送和接受的语法

// 读取数据
data := <-chan
// 写入数据
chan <- data

2、发送和接收默认是阻塞的

一个通道接收和发送数据默认是阻塞的。也就是说，当一个数据被发送到通道时，在发送语句中被阻塞，直到另一个goroutine从该通道读取数据，才解除阻塞。相应地，当从通道中读取数据时，读取被阻塞，直到一个goroutine向该通道中写入数据。

这些特性可以帮助goroutines有效地进行通信。

示例代码：

package main

import "fmt"

func main() {
    c := make(chan bool)
    go func() {
        for i := 0; i < 5; i++ {
            fmt.Println("i = ", i)
        }
        c <- true
    }()
    data := <-c
    fmt.Println(data)
    fmt.Println("main over")
}

运行结果

i =  0
i =  1
i =  2
i =  3
i =  4
true
main over

3、死锁

只向通道中读取或写入数据，而不写入或读取数据，就会造成阻塞，产生死锁。

示例代码：

package main

func main() {
    c := make(chan bool)
    // fatal error: all goroutines are asleep - deadlock!
    c <- true
}

4、通道使用注意事项：

• 用于goroutine，传递消息的。
• 通道，每个都有相关联的数据类型,nil chan，不能使用，类似于nil map，不能直接存储键值对。
• 使用通道传递数据：<-
chan <- data，发送数据到通道，向通道中写数据
  data <- chan，从通道中获取数据，从通道中读数据
• 阻塞：
  发送数据：chan <- data，阻塞的，直到另一条goroutine，读取数据来解除阻塞
  读取数据：data <- chan，也是阻塞的。直到另一条goroutine，写出数据解除阻塞。
• 本身channel就是同步的，意味着同一时间，只能有一条goroutine来操作。

5、关闭通道

发送者可以通过关闭通道，来通知接收方不会有更多的数据被发送到channel上。

close(chan)

接收者可以在接收来自通道的数据时使用额外的变量来检查通道是否已经关闭。

// ok 为true，表示成功的从通道中读取数据
// ok 为false，表示从关闭的通道中读取数据，将获得通道数据类型的零值。
v, ok := <- chan

示例代码：

package main

import "fmt"

func main() {
    controlChan := make(chan bool)
    c := make(chan int)
    go writeData(c, controlChan)
    go readData(c, controlChan)
    _ = <-controlChan
    fmt.Println("main over")
}

func writeData(c chan int, controlChan chan bool) {
    for i := 0; i < 5; i++ {
        c <- i
    }
    close(c)
    controlChan <- true
}

func readData(c chan int, controlChan chan bool) {
    for {
        v, ok := <-c
        if !ok {
            fmt.Println("数据读取完毕")
            break
        }
        fmt.Println("读取数据：", v)
    }
    controlChan <- true
}

运行结果

读取数据： 0
读取数据： 1
读取数据： 2
读取数据： 3
读取数据： 4
数据读取完毕
main over

我们可以循环从通道上获取数据，直到通道关闭。for循环的for range形式可用于从通道接收值，直到它关闭为止。

示例代码：

package main

import (
    "fmt"
)

func main() {
    c := make(chan int)
    go writeData(c)
    // for循环的for range形式可用于从通道接收值，直到它关闭为止。
    for v := range c {
        fmt.Println("读取数据：", v)
    }
    fmt.Println("main..over.....")
}
func writeData(c chan int) {
    for i := 0; i < 5; i++ {
        c <- i
    }
    close(c)
}

三、缓冲通道

非缓冲通道

c := make(chan T)

缓冲通道

c := make(chan T，cap)

示例代码：

package main

import (
    "fmt"
)

func main() {
    c := make(chan int, 3)
    go writeData(c)
    // for循环的for range形式可用于从通道接收值，直到它关闭为止。
    for v := range c {
        fmt.Println("\t读取数据：", v)
    }
    fmt.Println("main..over.....")
}
func writeData(c chan int) {
    for i := 1; i <= 6; i++ {
        c <- i
        fmt.Println("写入数据: ", i)
    }
    close(c)
}

运行结果：

写入数据:  1
写入数据:  2
写入数据:  3
写入数据:  4
        读取数据： 1
        读取数据： 2
        读取数据： 3
        读取数据： 4
        读取数据： 5
写入数据:  5
写入数据:  6
        读取数据： 6
main..over.....

四、定向通道

// 双向通道
c1 := make(chan T)
// 只写通道
c2 := make(chan<- T)
// 只读通道
c3 := make(<-chan T)

定义一个单向（定向）通道是没有意义的，单向通道往往用作函数的参数。
示例代码：

package main

import (
    "fmt"
)

func main() {
    c := make(chan int, 3)
    done := make(chan bool)
    go writeData(c, done)
    go readData(c, done)
    <-done
    fmt.Println("main..over.....")
}
func writeData(c chan<- int, done chan bool) {
    for i := 1; i <= 6; i++ {
        c <- i
        fmt.Println("写入数据: ", i)
    }
    close(c)
    done <- true
}
func readData(c <-chan int, done chan bool) {
    for v := range c {
        fmt.Println("\t读取数据：", v)
    }
    done <- true
}