GO语言协程间通信,go 协程调度

Channel简易教程

不同于传统的多线程并发模型使用共享内存来实现线程间通信的方式,golang 的哲学是通过 channel 进行协程(goroutine)之间的通信来实现数据共享。这种方式的优点是通过提供原子的通信原语,避免了竞态情形(race condition)下复杂的锁机制。

创新互联公司主要从事网站设计制作、做网站、网页设计、企业做网站、公司建网站等业务。立足成都服务宁波,10余年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:18982081108

channel 可以看成一个 FIFO 队列,对 FIFO 队列的读写都是原子的操作,不需要加锁。对 channel 的操作行为结果总结如下:

读取一个已关闭的 channel 时,总是能读取到对应类型的零值,为了和读取非空未关闭 channel 的行为区别,可以使用两个接收值:

golang 中大部分类型都是值类型(只有 slice / channel / map 是引用类型),读/写类型是值类型的 channel 时, 如果元素 size 比较大时,应该使用指针代替,避免频繁的内存拷贝开销 。

main方法里创建了一个string类型的Channel,实现主协程与子协程 go SendMessage 进行通信。主协程执行到 -values 时发生阻塞,等待读取 values Channel的值,而子协程执行 SendMessage 方法时写入 values Channel。即,主协程发生阻塞,等待子协程执行完毕后再继续执行。

执行的结果如下:

从日志可以看出,打印val语句必须在子协程 go SendMessage 执行完成后才执行。

如果在此基础上添加多一个协程写入 values Channel会发生什么?

在主协程中,启动两个子协程给Channel写数据。而在 SendMessage 方法里,为了达到显示效果,在写入Channel前先睡眠1秒,在主协程也添加睡眠时间。

执行日志打印如下:

发现只有其中一个协程完成写入Channel的操作。因为此Channel没有设置缓存,所有只能保存一个写入值。

那么如何才能保证两个子协程能正常写入Channel呢?

为了保证上面的两个子协程能顺利地把值写入Channel,我们创建一个带缓冲的Channel。

新创建的Channel缓冲两个值,这样就能保证两个子协程能正常写入到Channel中。下面看看打印日志:

如我们猜想一样,两个子协程都能顺利结束。

晚安~

Go CSP并发模型

Go的CSP并发模型

Go实现了两种并发形式。第一种是大家普遍认知的:多线程共享内存。其实就是Java或者C++等语言中的多线程开发。另外一种是Go语言特有的,也是Go语言推荐的:CSP(communicating sequential processes)并发模型。

CSP 是 Communicating Sequential Process 的简称,中文可以叫做通信顺序进程,是一种并发编程模型,由 Tony Hoare 于 1977 年提出。简单来说,CSP 模型由并发执行的实体(线程或者进程)所组成,实体之间通过发送消息进行通信,这里发送消息时使用的就是通道,或者叫 channel。CSP 模型的关键是关注 channel,而不关注发送消息的实体。 Go 语言实现了 CSP 部分理论 。

“ 不要以共享内存的方式来通信,相反, 要通过通信来共享内存。”

Go的CSP并发模型,是通过 goroutine和channel 来实现的。

goroutine 是Go语言中并发的执行单位。其实就是协程。

channel是Go语言中各个并发结构体(goroutine)之前的通信机制。 通俗的讲,就是各个goroutine之间通信的”管道“,有点类似于Linux中的管道。

Channel

Goroutine

为什么go语言适合开发网游服务器端

前段时间在golang-China读到这个贴:

个人觉得golang十分适合进行网游服务器端开发,写下这篇文章总结一下。

从网游的角度看:

要成功的运营一款网游,很大程度上依赖于玩家自发形成的社区。只有玩家自发形成一个稳定的生态系统,游戏才能持续下去,避免鬼城的出现。而这就需要多次大量导入用户,在同时在线用户量达到某个临界点的时候,才有可能完成。因此,多人同时在线十分有必要。

再来看网游的常见玩法,除了排行榜这类统计和数据汇总的功能外,基本没有需要大量CPU时间的应用。以前的项目里,即时战斗产生的各种伤害计算对CPU的消耗也不大。玩家要完成一次操作,需要通过客户端-服务器端-客户端这样一个来回,为了获得高响应速度,满足玩家体验,服务器端的处理也不能占用太多时间。所以,每次请求对应的CPU占用是比较小的。

网游的IO主要分两个方面,一个是网络IO,一个是磁盘IO。网络IO方面,可以分成美术资源的IO和游戏逻辑指令的IO,这里主要分析游戏逻辑的IO。游戏逻辑的IO跟CPU占用的情况相似,每次请求的字节数很小,但由于多人同时在线,因此并发数相当高。另外,地图信息的广播也会带来比较频繁的网络通信。磁盘IO方面,主要是游戏数据的保存。采用不同的数据库,会有比较大的区别。以前的项目里,就经历了从MySQL转向MongoDB这种内存数据库的过程,磁盘IO不再是瓶颈。总体来说,还是用内存做一级缓冲,避免大量小数据块读写的方案。

针对网游的这些特点,golang的语言特性十分适合开发游戏服务器端。

首先,go语言提供goroutine机制作为原生的并发机制。每个goroutine所需的内存很少,实际应用中可以启动大量的goroutine对并发连接进行响应。goroutine与gevent中的greenlet很相像,遇到IO阻塞的时候,调度器就会自动切换到另一个goroutine执行,保证CPU不会因为IO而发生等待。而goroutine与gevent相比,没有了python底层的GIL限制,就不需要利用多进程来榨取多核机器的性能了。通过设置最大线程数,可以控制go所启动的线程,每个线程执行一个goroutine,让CPU满负载运行。

同时,go语言为goroutine提供了独到的通信机制channel。channel发生读写的时候,也会挂起当前操作channel的goroutine,是一种同步阻塞通信。这样既达到了通信的目的,又实现同步,用CSP模型的观点看,并发模型就是通过一组进程和进程间的事件触发解决任务的。虽然说,主流的编程语言之间,只要是图灵完备的,他们就都能实现相同的功能。但go语言提供的这种协程间通信机制,十分优雅地揭示了协程通信的本质,避免了以往锁的显式使用带给程序员的心理负担,确是一大优势。进行网游开发的程序员,可以将游戏逻辑按照单线程阻塞式的写,不需要额外考虑线程调度的问题,以及线程间数据依赖的问题。因为,线程间的channel通信,已经表达了线程间的数据依赖关系了,而go的调度器会给予妥善的处理。

另外,go语言提供的gc机制,以及对指针的保护式使用,可以大大减轻程序员的开发压力,提高开发效率。

展望未来,我期待go语言社区能够提供更多的goroutine间的隔离机制。个人十分推崇erlang社区的脆崩哲学,推动应用发生预期外行为时,尽早崩溃,再fork出新进程处理新的请求。对于协程机制,需要由程序员保证执行的函数不会发生死循环,导致线程卡死。如果能够定制goroutine所执行函数的最大CPU执行时间,及所能使用的最大内存空间,对于提升系统的鲁棒性,大有裨益。

2020-08-20:GO语言中的协程与Python中的协程的区别?

福哥答案2020-08-20:

1.golang的协程是基于gpm机制,是可以多核多线程的。Python的协程是eventloop模型(IO多路复用技术)实现,协程是严格的 1:N 关系,也就是一个线程对应了多个协程。虽然可以实现异步I/O,但是不能有效利用多核(GIL)。

2.golang用go func。python用import asyncio,async/await表达式。

评论

channel使用

【译文】 原文地址

channel是Go语言的一个标志性特性,为go协程之间的数据交互提供一种非常强大的方式,而不需要使用锁机制。

本文将讨论channel的两个重要属性,一个是控制协程间数据发送和接收,以及对channel本身控制。

首先讨论下关闭的channel特性。一旦channel被关闭之后,就不能再继续发送数据给该channel,但是还是可以继续接收channel中的数据。如下所示:

output:

上述例子显示即使ch在for循环之前已经关闭,但还是可以正常的读取缓存中的true值,读完之后ok就会被赋值为false表示channel已经关闭,而且value值为对应channel类型bool的默认零值false。只要不停地从关闭的channel接收,就会无限的返回默认值和false。可以将for循环次数改大点试试即可验证。

通过以上例子可以发现,关闭的channel可以继续接收读取操作,这种特征是有用的。在使用range读取带缓存的channel时就会用到,一旦channel关闭,读取完缓存中数据就会停止接收数据退出。

将前面的例子改为如下:

output:

上面的例子就没有false打出来了。正好是写入channel里面的两个值。

channel与select结合更能发挥出其作用,让我们看一个例子:

上面的例子,因为finish在主协程中发送之后,马上就会在select中接收,并执行done.Done()。主协程wait马上会退出整个程序就结束。但是这里面存在一个问题,如果在select中没有添加finish case的话,主协程就永远发送不了数据到finish这个channel,因为其不带缓存。这里就可以通过将finish改成带缓存的channel,或者可以让select中的finish不会阻塞。

但是出现多个协程都在接收finish通道中的数据的话,就需要发送对应协程数量的值到channel中才能解决上面的问题。但是具体有多少个协程这往往是不好确定的,因为有些协程可能是程序其他部分创建的。一个比较好的选择就是通过使用关闭通道的方法来实现各协程能正常接收并结束。

如下所示:

output:

上面的例子就是使用了关闭的channel可以无限地接收到反馈数据。这样每个协程都能从finish通道中读到关闭信息并执行done.Done()使得主协程wait能退出。并且不需要关注多少个协程数,就能正确的让所有协程读到finish通道信息。

channel的这个特性,可以让程序员无需关注后台具体执行协程个数,确保每个协程都能接收到通道关闭信息,而无需担心死锁问题。

通过上面的例子我们也发现每个协程并不需要从通道中读取对应类型的数据,只需让接收操作能执行就行,让select不被阻塞。所以可以使用空结构体类型,我们可以改成如下:

这里我们只关注通道是否关闭这个信号,而不需要关注通道里面的数据,所以可使用空结构体类型通道。

第二个要讨论的是nil通道:如果定义了一个channel变量没有被初始化,或者被赋值为nil,那么该chennel总是处于阻塞状态。如下所示:

执行结果为:

因为channel为nil无法发送数据,当然也不能接收数据:

这个似乎看起来不是很重要,但是如果你想使用关闭channel来等待多个channel关闭的话,这个特性就有用处了。先看下面的例子:

WaitMany()函数看起来好像是一个等待通道a和b关闭的好方法,但是存在一个问题。假设a通道先关闭,case -a就会变成非阻塞。因为bclosed还是false,程序就会进入到一个死循环当中,导致b通道永远无法确认关闭。

一个安全的方法就是使用nil通道总是阻塞的特点,如下所示:

上面的例子我们在WaitMany函数当中,当a或者b关闭时,case可执行了将对应的通道赋值为nil,让其阻塞这样就可以等待另一个通道关闭。当nil通道是select语句的一部分时,它会被有效地忽略,因此nil通道a会从select中删除它,只留下b,直到它被关闭,退出循环。

总之,closed和nil通道的简单属性对写出优质的go程序是很有用的,可以用来创建高并发程序。

协程与异步IO

协程,又称微线程,纤程。英文名 Coroutine 。Python对协程的支持是通过 generator 实现的。在generator中,我们不但可以通过for循环来迭代,还可以不断调用 next()函数 获取由 yield 语句返回的下一个值。但是Python的yield不但可以返回一个值,它还可以接收调用者发出的参数。yield其实是终端当前的函数,返回给调用方。python3中使用yield来实现range,节省内存,提高性能,懒加载的模式。

asyncio是Python 3.4 版本引入的 标准库 ,直接内置了对异步IO的支持。

从Python 3.5 开始引入了新的语法 async 和 await ,用来简化yield的语法:

import asyncio

import threading

async def compute(x, y):

print("Compute %s + %s ..." % (x, y))

print(threading.current_thread().name)

await asyncio.sleep(x + y)

return x + y

async def print_sum(x, y):

result = await compute(x, y)

print("%s + %s = %s" % (x, y, result))

print(threading.current_thread().name)

if __name__ == "__main__":

loop = asyncio.get_event_loop()

tasks = [print_sum(1, 2), print_sum(3, 4)]

loop.run_until_complete(asyncio.wait(tasks))

loop.close()

线程是内核进行抢占式的调度的,这样就确保了每个线程都有执行的机会。而 coroutine 运行在同一个线程中,由语言的运行时中的 EventLoop(事件循环) 来进行调度。和大多数语言一样,在 Python 中,协程的调度是非抢占式的,也就是说一个协程必须主动让出执行机会,其他协程才有机会运行。

让出执行的关键字就是 await。也就是说一个协程如果阻塞了,持续不让出 CPU,那么整个线程就卡住了,没有任何并发。

PS: 作为服务端,event loop最核心的就是IO多路复用技术,所有来自客户端的请求都由IO多路复用函数来处理;作为客户端,event loop的核心在于利用Future对象延迟执行,并使用send函数激发协程,挂起,等待服务端处理完成返回后再调用CallBack函数继续下面的流程

Go语言的协程是 语言本身特性 ,erlang和golang都是采用了CSP(Communicating Sequential Processes)模式(Python中的协程是eventloop模型),但是erlang是基于进程的消息通信,go是基于goroutine和channel的通信。

Python和Go都引入了消息调度系统模型,来避免锁的影响和进程/线程开销大的问题。

协程从本质上来说是一种用户态的线程,不需要系统来执行抢占式调度,而是在语言层面实现线程的调度 。因为协程 不再使用共享内存/数据 ,而是使用 通信 来共享内存/锁,因为在一个超级大系统里具有无数的锁,共享变量等等会使得整个系统变得无比的臃肿,而通过消息机制来交流,可以使得每个并发的单元都成为一个独立的个体,拥有自己的变量,单元之间变量并不共享,对于单元的输入输出只有消息。开发者只需要关心在一个并发单元的输入与输出的影响,而不需要再考虑类似于修改共享内存/数据对其它程序的影响。


当前名称:GO语言协程间通信,go 协程调度
转载源于:http://pwwzsj.com/article/hcoesc.html