[golang] channel通道

说明

channel是go当中的一个核心类型，可以看做是管道。并发核心单元可以通过channel进行数据的发送和接收，从而实现通信。

在go中，channel是一种数据类型，主要被用来解决协程的同步问题以及协程之间数据共享(数据传递)的问题。

go当中的goroutine运行在相同的地址空间，因此访问共享内存地址必须做好同步，goroutine奉行通过通信来共享内存，而不是共享内存来通信。

引用类型channel可用于多个goroutine通讯，在其内部实现了同步，确保并发安全。

定义channel变量

在go中，channel也一个对应make创建的底层数据结构的引用。

当我们复制一个channel或者用于函数参数传递的时候，我们只是拷贝了一个channel引用，因此调用者和被调用者将引用同一个channel对象，和其他的引用类型一样，channel的零值也是nil。

定义一个channel的时候，也需要定义发送到channel的值的类型，channel可以使用内置的make函数来进行创建。

chan是创建channel使用的关键字，Type代表着channel收发数据的类型。

make(chan Type) // 等价于make(chan Type,0)
make(chan Type,capacity)

当 参数capacity= 0 时，channel 是无缓冲阻塞读写的；当capacity > 0 时，channel 有缓冲、是非阻塞的，直到写满 capacity个元素才阻塞写入。

channel非常像生活中的管道，一边可以存放东西，另一边可以取出东西。channel通过操作符 <- 来接收和发送数据，发送和接收数据语法：

package main

import "fmt"

func main() {
	// 创建一个channel
	ch := make(chan int)
	// 创建一个子goroutine,在这个goroutine中进行数据的写入
	go worker(ch)
	// 读取channel通道中的数据
	num := <- ch
	fmt.Println("channel通道中读到的数据为:",num)
}

func worker(ch chan int) {
	// 向channel通道中写入数据
	ch <- 10
}

在上面的代码中，我们通过chan <- val 来进行channel值的写入，通过val := <- chan 来进行channel的值的读取。

我们首先创建了一个goroutine用来向channel管道中进行数据的写入，然后同时在main goroutine中进行数据的读取。

输出的结果为：

channel通道中读到的数据为: 10

Process finished with exit code 0

如果channel(无缓冲)的一头发生了读操作或者写操作，而在另外一头没有进行相对应的操作，那么就会发生阻塞，直到channel的另一头发生相应的操作。

默认情况下，channel接收和发送数据都是阻塞的，除非另一端已经准备好，这样就使得goroutine同步变的更加的简单，而不需要显式的lock。

package main

import (
    "fmt"
)

func main() {
    c := make(chan int)

    go func() {
        defer fmt.Println("子协程结束")

        fmt.Println("子协程正在运行……")

        c <- 666 //666发送到c
    }()

    num := <-c //从c中接收数据，并赋值给num

    fmt.Println("num = ", num)
    fmt.Println("main协程结束")
}

程序运行结果：

当进行读取数据的时候，可以采用下面的形式来判断数据是否传输完毕：

 x, ok := <-channel 

如果数据传输完毕，ok的值为false，否则为true。

package main

import "fmt"

func main() {
	// 创建一个channel
	ch := make(chan int)

	// 创建一个goroutine用来向channel中写入数据
	go func() {
		defer close(ch) // 通过close函数可以关闭channel通道
		for i:=0;i<5;i++ {
			ch <- i // 将i值写入channel
		}
	}()

	// 在主goroutine中读取channel通道传递的值
	for {
		val,ok := <-ch
		if !ok { // ok 为false时表示读取结束
			fmt.Println("读取结束,over")
			break
		}
		fmt.Println("读取到的数据为:",val)
	}
}

输出的结果为:

读取到的数据为: 0
读取到的数据为: 1
读取到的数据为: 2
读取到的数据为: 3
读取到的数据为: 4
读取结束,over

Debugger finished with exit code 0

定义无缓冲的channel

无缓冲的通道（unbuffered channel）是指在接收前没有能力保存任何值的通道。

这种类型的通道要求发送goroutine和接收goroutine同时准备好，才能完成发送和接收操作。否则，通道会导致先执行发送或接收操作的 goroutine 阻塞等待。

这种对通道进行发送和接收的交互行为本身就是同步的。其中任意一个操作都无法离开另一个操作单独存在。

例如上面我们写的程序其实都是无缓冲的channel。

阻塞：由于某种原因数据没有到达，当前协程（线程）持续处于等待状态，直到条件满足，才接触阻塞。

同步：在两个或多个协程（线程）间，保持数据内容一致性的机制。

下图展示两个 goroutine 如何利用无缓冲的通道来共享一个值：

定义有缓冲的channel

有缓冲的通道（buffered channel）是一种在被接收前能存储一个或者多个数据值的通道。

这种类型的通道并不强制要求 goroutine 之间必须同时完成发送和接收。通道会阻塞发送和接收动作的条件也不同。

只有通道中没有要接收的值时，接收动作才会阻塞。

只有通道没有可用缓冲区容纳被发送的值时，发送动作才会阻塞。

这导致有缓冲的通道和无缓冲的通道之间的一个很大的不同：无缓冲的通道保证进行发送和接收的 goroutine 会在同一时间进行数据交换；有缓冲的通道没有这种保证。

示例图如下：

有缓冲的channel创建格式：

make(chan Type, capacity)

如果给定了一个缓冲区容量，通道就是异步的。只要缓冲区有未使用空间用于发送数据，或还包含可以接收的数据，那么其通信就会无阻塞地进行。

package main

import "fmt"

func main() {
	// 定义一个有缓冲的channel
	ch := make(chan int,2)

	// 创建一个goroutine，用来写入数据
	go func() {
		defer close(ch)
		for i:=0;i<5;i++ {
			ch <- i
			fmt.Println("写入的数据为:",i) // print操作属于io操作，可能导致cpu时间片切换
		}
	}()

	for {
		num,ok := <- ch
		if !ok {
			fmt.Println("读取结束,over")
			break
		}
		fmt.Println("读取到的数据为:",num)
	}
}

运行的结果为:

写入的数据为: 0
读取到的数据为: 0
读取到的数据为: 1
写入的数据为: 1
写入的数据为: 2
写入的数据为: 3
写入的数据为: 4
读取到的数据为: 2
读取到的数据为: 3
读取到的数据为: 4
读取结束,over

Process finished with exit code 0

关闭channel

如果发送者知道，没有更多的值需要发送到channel的话，那么让接收者也能及时知道没有多余的值可接收将是有用的，因为接收者可以停止不必要的接收等待。这可以通过内置的close函数来关闭channel实现。

package main

import (
    "fmt"
)

func main() {
    c := make(chan int)

    go func() {
        for i := 0; i < 5; i++ {
            c <- i
        }
        //把 close(c) 注释掉，程序会一直阻塞在 if data, ok := <-c; ok 那一行
        close(c)
    }()

    for {
        //ok为true说明channel没有关闭，为false说明管道已经关闭
        if data, ok := <-c; ok {
            fmt.Println(data)
        } else {
            break
        }
    }

    fmt.Println("Finished")
}

程序运行结果：

注意：

• channel不像文件一样需要经常去关闭，只有当你确实没有任何发送数据了，或者你想显式的结束range循环之类的，才去关闭channel；

• 关闭channel后，无法向channel 再发送数据(引发 panic 错误后导致接收立即返回零值)；

• 关闭channel后，可以继续从channel接收数据；

• 对于nil channel，无论收发都会被阻塞。

可以使用 range 来迭代不断操作channel：

package main

import (
    "fmt"
)

func main() {
    c := make(chan int)

    go func() {
        for i := 0; i < 5; i++ {
            c <- i
        }
        //把 close(c) 注释掉，程序会一直阻塞在 for data := range c 那一行
        close(c)
    }()

    for data := range c {
        fmt.Println(data)
    }
    fmt.Println("Finished")
}

单向channel

默认情况下，通道channel是双向的，也就是，既可以往里面发送数据也可以同里面接收数据。

但是，我们经常见一个通道作为参数进行传递而值希望对方是单向使用的，要么只让它发送数据，要么只让它接收数据，这时候我们可以指定通道的方向。

单向channel变量的声明非常简单，如下：

var ch1 chan int       // ch1是一个正常的channel，是双向的
var ch2 chan<- float64 // ch2是单向channel，只用于写float64数据
var ch3 <-chan int     // ch3是单向channel，只用于读int数据

//   chan<- //只写
func counter(out chan<- int) {
    defer close(out)
    for i := 0; i < 5; i++ {
        out <- i //如果对方不读 会阻塞
    }
}

//   <-chan //只读
func printer(in <-chan int) {
    for num := range in {
        fmt.Println(num)
    }
}

func main() {
    c := make(chan int) //   chan   //读写

    go counter(c) //生产者
    printer(c)    //消费者

    fmt.Println("done")
}