go语言 - 通道

概述

上篇博文说明了 go 语言的并发机制 ----- go 协程（goroutine），本文将介绍并发通信机制；

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

引用类型 channel 是CSP 模式的具体体现，用户多个 goroutine 通讯；其内部实现了同步，确保并发安全。

channel 默认为同步模式，需要发送和接收配对。否则会被阻塞，知道另一方准备好后被唤醒。

 

channel

和map 类似， channel也是一个对应 make 创建的底层数据结构的引用

当复制一个channel 或用户函数参数传递时，我们只是拷贝了一个channel 引用

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

make(chan Type)
make(chan Type, capacity)

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

channel 通过操作符 <- 来接收和发送数据，发送和接收数据语法：

channel <- value      //发送value 到 channel
 <-channel             //接收并将其丢弃
 x := <-channel        //从channel中接收数据，并赋值给x
 x, ok := <-channel    //从channel中接收数据，并赋值给x，同时检查通道是否已关闭或者是否为空

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

channel 简单示例：

package main

import (
	"fmt"
	"time"
)

func main() {

	// //创建一个channel ch
	ch := make(chan string)

	go func() {
		defer fmt.Println("子协程调用完毕...")

		for i := 0; i < 2; i++ {
			fmt.Println("i = ", i)
			time.Sleep(time.Second)
		}
		fmt.Println("我是子协程，已工作完毕")
		ch <- "我是子协程，已工作完毕"
	}()

	// <-ch 没有数据前， 会一直阻塞
	str := <-ch
	fmt.Println("str = ", str)
}

执行结果如下：

------------------------------------------------------------
~/work_space/go_works/src/admin/channel » go run channelOps.go                                                                                   ryanxu@iterm
i =  0
i =  1
我是子协程，已工作完毕
子协程调用完毕...
str =  我是子协程，已工作完毕

 

无缓存 channel

无缓冲的Channel创建格式

make(chan Type)
make(chan Type, 0)

两种方式等价；
如果没有指定缓冲区容量，那么该通道就是同步的，因此会阻塞到发送者准备好发送和接收者准备好接收

package main

import (
	"fmt"
	"time"
)

func main() {

	//创建一个无缓存的channel
	ch := make(chan int, 0)

	//len(ch) 缓冲去剩余数据个数， cap(ch) 缓冲区大小
	fmt.Printf("len(ch) = %d \t, cap(ch) = %d \n", len(ch), cap(ch))

	//新建一个协程
	go func() {
		for i := 0; i < 3; i++ {
			fmt.Println("子协程： i = ", i)
			ch <- i //往ch 中 写数据
		}
	}()

	time.Sleep(2 * time.Second)

	for i := 0; i < 3; i++ {
		num := <-ch
		fmt.Println("num = ", num)
	}
}

执行结果如下：
 

------------------------------------------------------------
~/work_space/go_works/src/admin/channel » go run channelOps.go                                                                                   ryanxu@iterm
len(ch) = 0     , cap(ch) = 0
子协程： i =  0
num =  0
子协程： i =  1
子协程： i =  2
num =  1
num =  2
------------------------------------------------------------
~/work_space/go_works/src/admin/channel »    

 

有缓存 Channel

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

这种类型的通道并不强制要求goroutine 之间必须同时完成发送和接收。通道会阻塞发送和接收动作的条件也会不同。只有在通道中没有要接收的值时，接收动作才会阻塞。只有在通道没有可用缓冲区容纳被发送的值时，发送动作才会阻塞。

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

有缓冲的Channel创建格式

make(chan Type, capacity) //capacity > 0 

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

package main

import (
	"fmt"
	"time"
)

func main() {

	//创建一个有缓冲的channel
	ch := make(chan int, 3)
	fmt.Printf("len(ch) = %d \t, cap(ch) = %d \n", len(ch), cap(ch))
	//新建一个协程
	go func() {
		for i := 0; i < 10; i++ {
			ch <- i //往ch 中 写数据
			fmt.Printf("子协程[%d]：len(ch) = %d \t, cap(ch) = %d \n", i, len(ch), cap(ch))

		}
	}()

	time.Sleep(2 * time.Second)

	for i := 0; i < 10; i++ {
		num := <-ch
		fmt.Println("num = ", num)
	}
}

执行结果如下：

~/work_space/go_works/src/admin/channel » go run channelOps.go                                                                                   ryanxu@iterm
len(ch) = 0     , cap(ch) = 3
子协程[0]：len(ch) = 1  , cap(ch) = 3
子协程[1]：len(ch) = 2  , cap(ch) = 3
子协程[2]：len(ch) = 3  , cap(ch) = 3
num =  0
子协程[3]：len(ch) = 3  , cap(ch) = 3
子协程[4]：len(ch) = 3  , cap(ch) = 3
num =  1
num =  2
num =  3
子协程[5]：len(ch) = 2  , cap(ch) = 3
子协程[6]：len(ch) = 2  , cap(ch) = 3
子协程[7]：len(ch) = 3  , cap(ch) = 3
num =  4
num =  5
num =  6
num =  7
num =  8
子协程[8]：len(ch) = 0  , cap(ch) = 3
子协程[9]：len(ch) = 0  , cap(ch) = 3
num =  9
------------------------------------------------------

 

关闭channel 

close(channel_name)    //channel_name 指创建的通道对象

• channel 不想文件一样需要经常去关闭，只有当确定没有任何数据需要发送了，或者想显示结束range 循环之类的，才去关闭channel
• 关闭 Channel后， 无法想channel 再发送数据（引发panic错误后导致接收立即返回零值）
• 关闭Channel 后，可以继续想channel 接收数据
• 对于nil channel, 无论收发都会被阻塞

package main

import "fmt"

func main() {

	//创建一个无缓存channel
	ch := make(chan int, 0)

	go func() {
		for i := 0; i < 5; i++ {
			ch <- i //给通道写数据
		}
		//如果不需要再写数据的时候， 则关闭channel
		close(ch)
	}()

	for {
		if num, ok := <-ch; ok == true {
			fmt.Println("num = ", num)
		} else { //管道关闭
			break
		}

	}

}

执行结果如下：

~/work_space/go_works/src/admin/channel » go run channelOps.go                                                                                   ryanxu@iterm
num =  0
num =  1
num =  2
num =  3
num =  4
----------------------------------------------

单向通道

单向通道是指， 定义一个通道可以指定其为只读 或者 只写类型； 默认的 是 双向通道，即：可读可写； 

代码示例如下：
 

package main

import (
	"fmt"
)

func main() {

	//定义一个双向通道 ch
	ch := make(chan int)

	//生产者，生成数字，写入 ch
	go producer(ch) // channel 作为参数是引用传递

    //消费者，获取数字，从ch 接收 
	consumer(ch)

}

//单向，只写channel;
func producer(out chan<- int) {
	for i := 0; i < 10; i++ {
		out <- i * i
	}
    //关闭通道
	close(out)
}

//单向，只读channel
func consumer(in <-chan int) {
	//循环变量 通道in
	for num := range in {
		fmt.Println("num = ", num)
	}
}

程序运行结果：

~/work_space/go_works/src/admin/channel » go run channelOps.go                                                                                   ryanxu@iterm
num =  0
num =  1
num =  2
num =  3
num =  4
------------------------------------------------------------