go 技巧: 实现一个无限 buffer 的 channel
前言
总所周知,go
里面只有两种 channel
,一种是 unbuffered channel, 其声明方式为
ch := make(chan interface{})
另一种是 buffered channel,其声明方式为
bufferSize := 5
ch := make(chan interface{},bufferSize)
对于一个 buffered channel,无论它的 buffer 有多大,它终究是有极限的。这个极限就是该 channel 最初被 make 时,所指定的 bufferSize 。
jojo,buffer channel 的大小是有极限的,我不做 channel 了。
一旦 channel
满了的话,再往里面添加元素的话,将会阻塞。
so how can we make a infinite buffer channel?
本文参考了 medinum 上面的一篇文章,有兴趣的同学可以直接阅读原文。
实现
接口的设计
首先当然是建一个 struct
,在百度翻译的帮助下,我们将这个 struct
取名为 InfiniteChannel
type InfiniteChannel struct {
}
思考一下 channel
的核心行为,实际上就两个,一个流入(Fan in),一个流出(Fan out),因此我们添加如下几个 method。
func (c *InfiniteChannel) In(val interface{}) {
// todo
}
func (c *InfiniteChannel) Out() interface{} {
// todo
}
内部实现
通过 In()
接收的数据,总得需要一个地方来存放。我们可以用一个 slice
来存放,就算用 In()
往里面添加了很多元素,也可以通过 append()
来拓展 slice
,slice
的容量可以无限拓展下去(内存足够的话),所以 channel
也是 infinite
。 InfiniteChannel
的第一个成员就这么敲定下来的。
type InfiniteChannel struct {
data []interface{}
}
用户调用 In()
和 Out()
时,可能是并发的环境,在 go
中如何进行并发编程,最容易想到的肯定是 channel
了,因此我们在内部准备两个 channel
,一个 inChan
,一个 outChan
,用 inChan
来接收数据,用 outChan
来流出数据。
type InfiniteChannel struct {
inChan chan interface{}
outChan chan interface{}
data []interface{}
}
func (c *InfiniteChannel) In(val interface{}) {
c.inChan <- val
}
func (c *InfiniteChannel) Out() interface{} {
return <-c.outChan
}
其中, inChan
和 outChan
都是 unbuffered channel。
此外,也肯定是需要一个 select
来处理来自 inChan
和 outChan
身上的事件。因此我们另起一个协程,在里面做 select
操作。
func (c *InfiniteChannel) background() {
for true {
select {
case newVal := <-c.inChan:
c.data = append(c.data, newVal)
case c.outChan <- c.pop(): // pop() 将取出队列的首个元素
}
}
}
func NewInfiniteChannel() *InfiniteChannel {
c := &InfiniteChannel{
inChan: make(chan interface{}),
outChan: make(chan interface{}),
}
go c.background() // 注意这里另起了一个协程
return c
}
ps:感觉这也算是 go 并发编程的一个套路了。即
- 在 new struct 的时候,顺手 go 一个 select 协程,select 协程内执行一个 for 循环,不停的 select,监听一个或者多个 channel 的事件。
- struct 对外提供的 method,只会操作 struct 内的 channel(在本例中就是 inChan 和 outChan),不会操作 struct 内的其他数据(在本例中,In() 和 Out() 都没有直接操作 data)。
- 触发 channel 的事件后,由 select 协程进行数据的更新(在本例中就是 data )。因为只有 select 协程对除 channel 外的数据成员进行读写操作,且 go 保证了对于 channel 的并发读写是安全的,所以代码是并发安全的。
- 如果 struct 是 exported ,用户或许会越过 new ,直接手动 make 一个 struct,可以考虑将 struct 设置为 unexported,把它的首字母小写即可。
pop()
的实现也非常简单。
// 取出队列的首个元素,如果队列为空,将会返回一个 nil
func (c *InfiniteChannel) pop() interface{} {
if len(c.data) == 0 {
return nil
}
val := c.data[0]
c.data = c.data[1:]
return val
}
测试一下
用一个协程每秒钟生产一条数据,另一个协程每半秒消费一条数据,并打印。
func main() {
c := NewInfiniteChannel()
go func() {
for i := 0; i < 20; i++ {
c.In(i)
time.Sleep(time.Second)
}
}()
for i := 0; i < 50; i++ {
val := c.Out()
fmt.Print(val)
time.Sleep(time.Millisecond * 500)
}
}
// out
<nil>0<nil>1<nil>23<nil>4<nil><nil>5<nil>67<nil><nil>89<nil><nil>1011<nil>12<nil>13<nil>14<nil>15<nil>16<nil>17<nil><nil>1819<nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil>
Process finished with the exit code 0
可以看到,将 InfiniteChannel
内没有数据可供消费时,调用 Out()
将会返回一个 nil
,不过这也在我们的意料之中,原因是 pop()
在队列为空时,将会返回 nil。
目前 InfiniteChannel
的行为与标准的 channel
的行为是有出入的,go
中的 channel
,在没有数据却仍要取数据时会被阻塞,如何实现这个效果?
优化
我认为此处是是整篇文章最有技巧的地方,我第一次看到时忍不住拍案叫绝。
首先把原来的 background()
摘出来
func (c *InfiniteChannel) background() {
for true {
select {
case newVal := <-c.inChan:
c.data = append(c.data, newVal)
case c.outChan <- c.pop():
}
}
}
对 outChan
进行一个简单封装
func (c *InfiniteChannel) background() {
for true {
select {
case newVal := <-c.inChan:
c.data = append(c.data, newVal)
case c.outChanWrapper() <- c.pop():
}
}
}
func (c *InfiniteChannel) outChanWrapper() chan interface{} {
return c.outChan
}
目前为止,一切照旧。
点睛之笔来了:
func (c *InfiniteChannel) outChanWrapper() chan interface{} {
if len(c.data) == 0 {
return nil
}
return c.outChan
}
在 c.data
为空的时候,返回一个 nil
在 background()
中,当执行到 case c.outChan <- c.pop():
时,实际上将会变成:
case nil <- nil:
在 go
中,是无法往一个 nil
的 channel
中发送元素的。例如
func main() {
var c chan interface{}
select {
case c <- 1:
}
}
// fatal error: all goroutines are asleep - deadlock!
func main() {
var c chan interface{}
select {
case c <- 1:
default:
fmt.Println("hello world")
}
}
// hello world
因此,对于
select {
case newVal := <-c.inChan:
c.data = append(c.data, newVal)
case c.outChanWrapper() <- c.pop():
}
将会一直阻塞在 select
那里,直到 inChan
来了数据。
再测试一下
012345678910111213141516171819fatal error: all goroutines are asleep - deadlock!
最后,程序 panic
了,因为死锁了。
补充
实际上 channel
除了 In()
和 Out()
外,还有一个行为,即 close()
,如果 channel close 后,依旧从其中取元素的话,将会取出该类型的默认值。
func main() {
c := make(chan interface{})
close(c)
for true {
v := <-c
fmt.Println(v)
time.Sleep(time.Second)
}
}
// output
// <nil>
// <nil>
// <nil>
// <nil>
func main() {
c := make(chan interface{})
close(c)
for true {
v, isOpen := <-c
fmt.Println(v, isOpen)
time.Sleep(time.Second)
}
}
// output
// <nil> false
// <nil> false
// <nil> false
// <nil> false
我们也需要实现相同的效果。
func (c *InfiniteChannel) Close() {
close(c.inChan)
}
func (c *InfiniteChannel) background() {
for true {
select {
case newVal, isOpen := <-c.inChan:
if isOpen {
c.data = append(c.data, newVal)
} else {
c.isOpen = false
}
case c.outChanWrapper() <- c.pop():
}
}
}
func NewInfiniteChannel() *InfiniteChannel {
c := &InfiniteChannel{
inChan: make(chan interface{}),
outChan: make(chan interface{}),
isOpen: true,
}
go c.background()
return c
}
func (c *InfiniteChannel) outChanWrapper() chan interface{} {
// 这里添加了对 c.isOpen 的判断
if c.isOpen && len(c.data) == 0 {
return nil
}
return c.outChan
}
再测试一下
func main() {
c := NewInfiniteChannel()
go func() {
for i := 0; i < 20; i++ {
c.In(i)
time.Sleep(time.Second)
}
c.Close() // 这里调用了 Close
}()
for i := 0; i < 50; i++ {
val := c.Out()
fmt.Print(val)
time.Sleep(time.Millisecond * 500)
}
}
// output
012345678910111213141516171819<nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil><nil>
Process finished with the exit code 0
符合预期
遗憾
目前看上去已经很完美了,但是和标准的 channel
相比,仍然有差距。因为标准的 channel
是有这种用法的
v,isOpen := <- ch
可以通过 isOpen
变量来获取 channel
的开闭情况。
因此 InfiniteChannel
也应该提供一个类似的 method
func (c *InfiniteChannel) OutAndIsOpen() (interface{}, bool) {
// todo
}
可惜的是,要想得知 InfiniteChannel
是否是 Open
的,就必定要访问 InfiniteChannel
内的 isOpen
成员。
type InfiniteChannel struct {
inChan chan interface{}
outChan chan interface{}
data []interface{}
isOpen bool
}
而 isOpen
并非 channel
类型,根据之前的套路,这种非 channel
类型的成员只应该被 select
协程访问。一旦有多个协程访问,就会出现并发问题,除非加锁。
我不能接受!所以干脆不提供这个 method 了,嘿嘿。
完整代码
func main() {
c := NewInfiniteChannel()
go func() {
for i := 0; i < 20; i++ {
c.In(i)
time.Sleep(time.Second)
}
c.Close()
}()
for i := 0; i < 50; i++ {
val := c.Out()
fmt.Print(val)
time.Sleep(time.Millisecond * 500)
}
}
type InfiniteChannel struct {
inChan chan interface{}
outChan chan interface{}
data []interface{}
isOpen bool
}
func (c *InfiniteChannel) In(val interface{}) {
c.inChan <- val
}
func (c *InfiniteChannel) Out() interface{} {
return <-c.outChan
}
func (c *InfiniteChannel) Close() {
close(c.inChan)
}
func (c *InfiniteChannel) background() {
for true {
select {
case newVal, isOpen := <-c.inChan:
if isOpen {
c.data = append(c.data, newVal)
} else {
c.isOpen = false
}
case c.outChanWrapper() <- c.pop():
}
}
}
func NewInfiniteChannel() *InfiniteChannel {
c := &InfiniteChannel{
inChan: make(chan interface{}),
outChan: make(chan interface{}),
isOpen: true,
}
go c.background()
return c
}
// 取出队列的首个元素,如果队列为空,将会返回一个 nil
func (c *InfiniteChannel) pop() interface{} {
if len(c.data) == 0 {
return nil
}
val := c.data[0]
c.data = c.data[1:]
return val
}
func (c *InfiniteChannel) outChanWrapper() chan interface{} {
if c.isOpen && len(c.data) == 0 {
return nil
}
return c.outChan
}
参考
https://medium.com/capital-one-tech/building-an-unbounded-channel-in-go-789e175cd2cd
go 技巧: 实现一个无限 buffer 的 channel的更多相关文章
- Java性能优化之使用NIO提升性能(Buffer和Channel)
在软件系统中,由于IO的速度要比内存慢,因此,I/O读写在很多场合都会成为系统的瓶颈.提升I/O速度,对提升系统整体性能有着很大的好处. 在Java的标准I/O中,提供了基于流的I/O实现,即Inpu ...
- Java网络编程和NIO详解4:浅析NIO包中的Buffer、Channel 和 Selector
Java网络编程与NIO详解4:浅析NIO包中的Buffer.Channel 和 Selector 转自https://www.javadoop.com/post/nio-and-aio 本系列文章首 ...
- Java网络编程与NIO详解4:浅析NIO包中的Buffer、Channel 和 Selector
微信公众号[黄小斜]作者是蚂蚁金服 JAVA 工程师,目前在蚂蚁财富负责后端开发工作,专注于 JAVA 后端技术栈,同时也懂点投资理财,坚持学习和写作,用大厂程序员的视角解读技术与互联网,我的世界里不 ...
- iOS开发:一个无限滚动自动播放图片的Demo(Swift语言编码)
很久以前就想写这么一个无限滚动的Demo了,最近学习了下Swift,手中没有可以用来练手的Demo,所以才将它实现了. Github地址(由于使用了UIView+AutoLayout第三方进行布局,所 ...
- JAVA NIO简介-- Buffer、Channel、Charset 、直接缓冲区、分散和聚集、文件锁
IO 是主存和外部设备 ( 硬盘.终端和网络等 ) 拷贝数据的过程. IO 是操作系统的底层功能实现,底层通过 I/O 指令进行完成. Java标准io回顾 在Java1.4之前的I/O系统中,提供 ...
- NIO流—理解Buffer、Channel概念和NIO的读写操作
NIO流与IO流的区别 面向流与面向块 IO流是每次处理一个或多个字节,效率很慢(字符流处理的也是字节,只是对字节进行编码和解码处理). NIO流是以数据块为单位来处理,缓冲区就是用于读写的数据块.缓 ...
- Java NIO:Buffer、Channel 和 Selector
Buffer 一个 Buffer 本质上是内存中的一块,我们可以将数据写入这块内存,之后从这块内存获取数据. java.nio 定义了以下几个 Buffer 的实现,这个图读者应该也在不少地方见过了吧 ...
- 003——Netty之Buffer、Channel以及多路复用器Selector
Buffer 1.缓冲区类型 2.缓冲区定义 (1)Buffer是一个对象,其中包含写入与读出的数据.是新IO与原IO的重要区别.任何情况下访问NIO中的数据都需要通过缓存区进行操作. (2)Buff ...
- Java-NIO 之 Buffer 与 Channel
NIO:一种同步非阻塞的 I/O 模型,也是 I/O 多路复用的基础. 同步与异步 同步:发起一个调用后,被调用者未处理完请求之前,调用不返回. 异步:发起一个调用后,立刻得到被调用者的回应表示已接收 ...
随机推荐
- 手脱UPX3.91壳(练习)
0x01 准备 OD UPX加壳程序 可以加壳的软件 0x02 给软件加壳 我找了半天发现winhex不错,而且是没壳的可以直接加壳 1.复制一份可执行文件 将赋值好的文件用UPX3.91加壳 0x0 ...
- 逆向 stdio.h 函数库 fseek 函数(调试版本)
0x01 fseek 函数 函数原型:int fseek(FILE *stream, long int offset, int whence) 函数功能:设置流 stream 的文件位置为给定的偏移 ...
- Photoshop 第二课 工具-钢笔的使用
钢笔的使用 钢笔→ 是一个非常实用(主要用于)但是非常难操作(会者不难哦~)的工具. 钢笔属性中有三种状态:1.路径:2.形状:3.像素.其中路径和形状是我们最常用的状态.路径是一条用来圈定需要操作的 ...
- (二)SQL语句
语法规则 不区分大小写,但是建议关键字大写,表名.列名小写 SELECT * FROM user; 支持多行编写sql语言(在SQLyog中可以用F12来快速格式化语句) # 查询cno=20201/ ...
- 【maven】IDEA工程右边的maven配置中Plugins有重复的命令
问题 解决 换一个IDEA的版本,比如2020.02 参考链接 https://ask.csdn.net/questions/1060938 https://bbs.csdn.net/topics/3 ...
- 逆向工程初步160个crackme-------4
crackme–3因为涉及到浮点数操作以及一些指令和寄存器(由于本人对浮点指令不了解),所以先隔过去分析后面的程序. 工具:1. 按钮事件地址转换工具E2A 2. PEID 3. Ollydbg 首先 ...
- ACM基础板子
新生赛以后就正式成为一名acmer啦 ~虽然没有打过比赛呜呜呜 要好好学算法,拿一个牌牌嘛~ 这里就记录算法学习情况,也怕自己偷懒,学一个就记录,看看长时间拖更就是在摸鱼,摸鱼和鸽子都是本质 ,加油! ...
- laravel 伪静态实现
Route::get('show{id}.html',['as'=>'products.detail','uses'=>'companyController@show']) ->wh ...
- Git安装教程最新版本(国内gitee国外github)
Git安装教程最新版本(国内gitee国外github) 欢迎关注博主公众号「Java大师」, 专注于分享Java领域干货文章, 关注回复「资源」, 获取大师使用的typora主题: http://w ...
- [ML] 高德软件的路径规划原理
路径规划 Dijkstra s:起点:S:已知到起点最短路径的点:U:未知到起点最短路径的点 Step 1:S中只有起点s,从U中找出路径最短的 Step 2:更新U中的顶点和顶点对应的路径 重复St ...