课程咨询 :13623629309

太原PHP培训 > 达内新闻 > 太原php培训班:游戏服务端究竟解决了什么问题?
  • 太原php培训班:游戏服务端究竟解决了什么问题?

    发布:太原PHP培训      来源:伯乐在线      时间:2016-07-01

  • 1.写在前面

    既然是游戏服务端程序员,那博客里至少还是得有一篇跟游戏服务端有关的文章,今天文章主题就关于游戏服务端。写这篇博客之前也挺纠结的,一方面是因为游戏服务端其实不论架构上还是具体一些逻辑模块的构建,都属于非常成熟的技术,举个简单的例子,像端游的多zone/scene/game进程+单全局进程架构,网上随便一搜能搜出来几十篇内容差不多的。另一方面是因为中国特色MMO基本上把服务端程序员整成了业务逻辑狗,很多明星团队的业务狗基本上从入职第一天开始就成天写lua、写python,纯写lua/python,你是完全无法辨别一个程序员的vision强弱区别的,结果论资排辈导致vision弱的上去了。(也许vision强的出去创业了?)你就会发现,游戏服务端的话语权到底是被谁占据了。

    在我看来,游戏服务端程序员容易陷入两个误区:

    第一,游戏服务端实际上要解决的并不是性能问题。一方面,即使是千人同屏的端游(姑且不论这千人同屏是不是一个中国特色的伪需求,反正我是没法将千人同屏跟游戏乐趣联系在一起的),其服务端如果进程划分得当,一个场景进程也至多只有千级别entity的压力,性能问题退化为了逻辑狗的业务素养问题。另一方面,现在端游MOBA和手游时代,开房间式场景同步已经成为主流,各种逻辑狗进化来的资深人士不需要也没必要将性能挂在嘴边了。

    第二,大部分游戏服务端所谓框架的定位有误。服务端框架的设计有好有坏,判断一个设计好不好没有普适统一的标准,但是判断一个设计烂不烂一定是存在一个标准线的。简单列举几种烂设计:

    烂设计基础版本。帮你定义好框架中的几种角色,你要么全盘接受,要么全不接受,不存在中间状态。但是,提供一种简单的通信机制,以及外部与框架通信的clientLib。或者能让你定制开发其中一种角色,可以写外部driver。这样,虽然架构丑一点,至少还能提供一定程度的扩展性。

    烂设计进阶版本。除了满足基础版本的定义之外,还具有一些额外的烂特点:框架中的角色定义的特别二逼,举个例子,基础版本的烂设计在角色定义上可能只是大概区分了Db代理进程、Gate进程、逻辑进程,但是进阶版本会对逻辑进程进行区分,定义了不同的逻辑进程角色。这意味着什么?意味着我想写一个简单的单逻辑进程游戏是没办法用这个框架的,因为框架默认就集成进来了一堆莫名其妙的东西。更有甚者,我想要添加一种角色,是需要动手去改框架的。

    说实话,正是由于这类设计的存在,我在看到类似于“游戏服务端技术含量不高”这类论断的时候,总感觉辩无可辩,因为就这两种设计而言,我甚至除了代码逻辑复杂度之外看不到跟本科毕设级别的游戏服务器有什么区别。

    不知道算是不幸还是幸运,前段时间亲眼目睹了上述提到的某种设计的从无到有的过程。当然,今天写此文的目的不是为了将这种设计批判一番,每种设计的诞生都是与各种因素相关的,我们不能站在上帝视角去评判这个过程。今天写此文,是希望对自己这整整一年半的游戏服务端编码历程中的一些所思所惑做个整理,希望能带各位看官从另一个思路看游戏服务端。

    2.游戏服务端究竟解决了什么问题?

    从定义问题开始,简单直接地说,一套游戏服务端开发框架应该具有下面两种能力:

    定义了client到server、server到client、server到server的消息pipeline。

    描述了游戏世界状态的维护方式。

    下面就从这两点来展开这篇文章。

    3 消息pipeline

    3.1 经典消息pipeline

    3.1.1 场景同步

    当讨论到游戏服务端的时候,我们首先想到的会是什么?要回答这个问题,我们需要从游戏服务端的需求起源说起。

    定义问题

    游戏对服务端的需求起源应该有两个:

    第一种是单机游戏联网版,实现为主客机模式的话,主机部分可以看做服务端。

    第二种是所有mmo的雏形mud,跟webserver比较类似,一个host服务多clients,表现为cs架构。

    第一种需求长盛不衰,一方面是console游戏特别适合这一套,另一方面是最近几年手游起来了,碎片化的PVE玩法+开房间式同步PVP玩法也得到验证,毕竟MMO手游再怎么火也不可能改变手游时间碎片化的事实的,最近的皇家冲突也证明,手游不会再重走端游老路了。

    第二种需求就不用说了,网上大把例子可以参考。最典型的是假设有这样一块野地,上面很多玩家和怪,逻辑都在服务端驱动,好了,这类需求没其他额外的描述了。

    但是,解决方案毕竟是不断发展的,即使速度很慢。

    说不断发展是特指针对第一种需求的解决方案,发展原因就是国情,外挂太多。像war3这种都还是纯正的主客机,但是后来对战平台出现、发展,逐渐过渡成了cs架构。真正的主机 其实是建在服务器的,这样其实服务器这边也维护了房间状态。后来的一系列ARPG端游也都是这个趋势,服务端越来越重,逐渐变得与第二种模式没什么区别。 同理如现在的各种ARPG手游。

    说发展速度很慢特指针对第二种需求的解决方案,慢的原因也比较有意思,那就是wow成了不可逾越的鸿沟。bigworld在wow用之前名不见经传,wow用了之后国内厂商也跟进。发展了这么多年,现在的无缝世界服务端跟当年的无缝世界服务端并无二致。发展慢的原因就观察来说可能需求本身就不是特别明确,MMO核心用户是重社交的,无缝世界核心用户是重体验的。前者跑去玩了天龙八部和倩女不干了,说这俩既轻松又妹子多;后者玩了console游戏也不干了,搞了半天MMO无缝世界是让我更好地刷刷刷的。所以仔细想想,这么多年了,能数得上的无缝世界游戏除了天下就是剑网,收入跟重社交的那几款完全不在一个量级。

    两种需求起源,最终其实导向了同一种业务需求。传统MMO架构(就是之前说的天龙、倩女类架构),一个进程维护多个场景,每个场景里多个玩家,额外的中心进程负责帮玩家从一个场景/进程切到另一个场景/进程。bigworld架构,如果剥离开其围绕切进程所做的一些外围设施,核心工作流程基本就能用这一段话描述。

    抽象一下问题,那我们谈到游戏服务端首先想到的就应该是多玩家对同一场景的view同步,也就是场景服务。

    本节不会讨论帧同步或是状态同步这种比较上层的问题,我们将重点放在数据流上。

    如何实现场景同步?

    首先,我们看手边工具,socket。

    之所以不提TCP或UDP是因为要不要用UDP自己实现一套TCP是另一个待撕话题,这篇文章不做讨论。因此,我们假设,后续的实现是建立在对底层协议一无所知的前提之上的,这样设计的时候只要适配各种协议,到时候就能按需切换。

    socket大家都很熟悉,优点就是各操作系统上抽象统一。

    因此,之前的问题可以规约为:如何用socket实现场景同步?

    拓扑结构是这样的(之后的所有图片连接箭头的意思表示箭头指向的对于箭头起源的来说是静态的):

    太原达内php培训班

    场景同步有两个需求:

    low latency

    rich interaction

    要做到前者,最理想的情况就是由游戏程序员把控消息流的整套pipeline,换句话说,就是不借助第三方的消息库/连接库。当然,例外是你对某些第三方连接库特别熟悉,比如很多C++服务端库喜欢用的libevent,或者我在本篇文章提供的示例代码所依赖的,mono中的IO模块。

    要做到后者,就需要保持场景同步逻辑的简化,也就是说,场景逻辑最好是单线程的,并且跟IO无关。其核心入口就是一个主循环,依次更新场景中的所有entity,刷新状态,并通知client。

    正是由于这两个需求的存在,网络库的概念就出现了。网络库由于易于实现,概念简单,而且笼罩着“底层”光环,所以如果除去玩具性质的项目之外,网络库应该是程序员造过最多的轮子之一。

    那么,网络库解决了什么问题?

    抛开多项目代码复用不谈,网络库首先解决的一点就是,将传输层的协议(stream-based的TCP协议或packet-based的UDP协议)转换为应用层的消息协议(通常是packet-based)。对于业务层来说,接收到流和包的处理模型是完全不同的。对于业务逻辑狗来说,包显然是处理起来更直观的。

    流转包的方法很多,最简单的可伸缩的non-trivial buffer,ringbuffer,bufferlist,不同的结构适用于不同的需求,有的方便做zero-copy,有的方便做无锁,有的纯粹图个省事。因为如果没有个具体的testcast或者benchmark,谁比谁一定好都说不准。

    buffer需要提供的语义也很简单,无非就是add、remove。buffer是只服务于网络库的。

    网络库要解决的第二个问题是,为应用层建立IO模型。由于之前提到过的场景服务的rich interaction的特点,poll模型可以避免大量共享状态的存在,理论上应该是最合适场景服务的。所谓poll,就是IO线程准备好数据放在消息队列中,用户线程负责轮询poll,这样,应用层的回调就是由用户线程进入的,保证模型简单。

    而至于IO线程是如何准备数据的,平台不同做法不同。linux上最合适的做法是reactor,win最合适的做法就是proactor,一个例外是mono,mono跑在linux平台上的时候虽然IO库是reactor模型,但是在C#层面还是表现为proactor模型。提供统一poll语义的网络库可以隐藏这种平台差异,让应用层看起来就是统一的本线程poll,本线程回调。

    网络库要解决的第三个问题是,封装具体的连接细节。cs架构中一方是client一方是server,因此连接细节在两侧是不一样的。而由于socket是全双工的,因此之前所说的IO模型对于任意一侧都是适用的。

    连接细节的不同就体现在,client侧,核心需求是发起建立连接,外围需求是重连;server侧,核心需求是接受连接,外围需求是主动断开连接。而两边等到连接建立好,都可以基于这个连接构建同样的IO模型就可以了。

    现在,简单介绍一种网络库实现。

    一个连接好的socket对应一个connector。

    connector负责向上提供IO模型抽象(poll语义)。同时,其借助维护的一个connector_buffer,来实现流转包。

    网络库中的client部分主要组件是ClientNetwork,维护连接(与重连)与一条connector。

    网络库中的server部分主要组件是ServerNetwork,维护接受连接(与主动断开)与N条connector。

    Network层面的协议非常简单,就是len+data。

    具体代码不再在博客里贴了。请参考:Network

    引入新的问题

    如果类比马斯洛需求中的层次,有了网络库,我们只能算是解决了生理需求:可以联网。但是后面还有一系列的复杂问题。

    最先碰到的问题就是,玩家数量增加,一个进程扛不住了。那么就需要多个进程,每个进程服务一定数量的玩家。

    但是,给定任意两个玩家,他们总有可能有交互的需求。

    对于交互需求,比较直观的解决方案是,让两个玩家在各自的进程中跨进程交互。但是这就成了一个分布式一致性问题——两个进程中两个玩家的状态需要保持一致。至于为什么一开始没人这样做,我只能理解为,游戏程序员的计算机科学素养中位程度应该解决不了这么复杂的问题。

    因此比较流行的是一种简单一些的方案。场景交互的话,就限定两个玩家必须在同一场景(进程),比如攻击。其他交互的话,就借助第三方的协调者来做,比如公会相关的通常会走一个全局服务器等等。

    这样,服务端就由之前的单场景进程变为了多场景进程+协调进程。新的问题出现了:

    玩家需要与服务端保持多少条连接?

    一种方法是保持O(n)条连接,既不环保,扩展性又差,可以直接pass掉。

    那么就只能保持O(1)条连接,如此的话,如何确定玩家正与哪个服务端进程通信?

    要解决这个问题,我们只能引入新的抽象。

    3.1.2 Gate

    定义问题

    整理下我们的需求:

    玩家在服务端的entity可以在不同的进程中,也可以移动到同一个进程中。

    玩家只需要与服务端建立有限条连接,即有访问到任意服务端进程的可能性。同时,这个连接数量不会随服务端进程数量增长而线性增长。

    要解决这些需求,我们需要引入一种反向代理(reverse proxy)中间件。

    反向代理是服务端开发中的一种常见基础设施抽象(infrastructure abstraction),概念很简单,简单说就是内网进程不是借助这种proxy访问外部,而是被动地挂在proxy上,等外部通过这种proxy访问内部。

    更具体地说,反向代理就是这样一种server:它接受clients连接,并且会将client的上行包转发给后端具体的服务端进程。

    很多年前linux刚支持epoll的时候,流行一个c10k的概念,解决c10k问题的核心就是借助性能不错的反向代理中间件。

    游戏开发中,这种组件的名字也比较通用,通常叫Gate。

    Gate解决了什么问题

    首先,Gate作为server,可以接受clients的连接。这里就可以直接用我们上一节输出的网络库。同时,其可以接受服务端进程(之后简称backend)的连接,保持通信。

    其次,Gate能够将clients的消息转发到对应的backend。与此对应的,backend可以向Gate订阅自己关注的client消息。对于场景服务来说,这里可以增加一个约束条件,那就是限制client的上行消息不会被dup,只会导到一个backend上。

    仅就这两点而言,Gate已经能够解决上一节末提出的需求。做法就是client给消息加head,其中的标记可以供Gate识别,然后将消息路由到对应的backend上。比如公会相关的消息,Gate会路由到全局进程;场景相关的消息,Gate会路由到订阅该client的场景进程。同时,玩家要切场景的时候,可以由特定的backend(比如同样由全局进程负责)调度,让不同的场景进程向Gate申请修改对client场景相关消息的订阅关系,以实现将玩家的entity从场景进程A切到场景进程B。

    站在比需求更高的层次来看Gate的意义的话,我们发现,现在clients不需要关注backends的细节,backends也不需要关注clients的细节,Gate成为这一pipeline中唯一的静态部分(static part)。

    当然,Gate能解决的还不止这些。

    我们考虑场景进程最常见的一种需求。玩家的移动在多client同步。具体的流程就是,client上来一个请求移动包,路由到场景进程后进行一些检查、处理,再推送一份数据给该玩家及附近所有玩家对应的clients。

    如果按之前说的,这个backend就得推送N份一样的数据到Gate,Gate再分别转给对应的clients。

    这时,就出现了对组播(multicast)的需求。

    组播是一种通用的message pattern,同样也是发布订阅模型的一种实现方式。就目前的需求来说,我们只需要为client维护组的概念,而不需要做inter-backend组播。

    这样,backend需要给多clients推送同样的数据时,只需要推送一份给Gate,Gate再自己dup就可以了——尽管带来的好处有限,但是还是能够一定程度降低内网流量。

    那接下来就介绍一种Gate的实现。

    我们目前所得出的Gate模型其实包括两个组件:

    针对路由client消息的需求,这个组件叫Broker。Broker的定义可以参考zguide对DEALER+ROUTER pattern的介绍。Broker的工作就是将client的消息导向对应的backend。

    针对组播backend消息的需求,这个组件叫Multicast。简单来说就是维护一个组id到clientIdList的映射。

    Gate的工作流程就是,listen两个端口,一个接受外网clients连接,一个接受内网backends连接。

    Gate有自己的协议,该协议基于Network的len+data协议之上构建。

    clients的协议处理组件与backends的协议处理组件不同,前者只处理部分协议(不会识别组控制相关协议,订阅协议)。

    在具体的实现细节上,判断一个client消息应该路由到哪个backend,需要至少两个信息:一个是clientId,一个是key。

    同一个clientId的消息有可能会路由到不同的backend上。

    当然,Gate的协议设计可以自由发挥,将clientId+key组成一个routingKey也是可以的。

    引入Gate之后的拓扑:

    太原达内php培训班

    具体代码请参考:GateSharp

    引入新的问题

    现在我们在需求的金字塔上更上了一层。之前我们是担心玩家数量增长会导致服务端进程爆掉,现在我们已经可以随意扩容backend进程,我们还可以通过额外实现的全局协调者进程来实现Gate的多开与动态扩容。甚至,我们可以通过构建额外的中间层,来实现服务端进程负载动态伸缩,比如像bigworld那样,在场景进程与Gate之间再隔离出一层玩家agent层。

    可以说,在这种方案成熟之后,程序员之间开始流行“游戏开发技术封闭”这种说法了。

    为什么?

    举一个简单的例子,大概描述下现在一个游戏项目的服务端生命周期状况:

    第一阶段,大概到目前这篇文章的进度为止,实现了场景内跑跳打。

    第二阶段,疯狂地为场景进程增加逻辑,各种跟游戏有关的逻辑全加进来,直到这部分的代码量占到整个服务端代码量的80%以上。

    第三阶段,有节操的程序员考虑拆分进程,当然,一开始的协调者进程一直都会存在,毕竟有些需求是场景进程无论如何都实现不了的。拆分进程的典型例子有聊天、邮件、公会等等。拆分出来的进程基本上是对场景进程代码轮廓的拷贝粘贴,删掉逻辑就开始在这之上写了。

    结果就是,产出了几个玩具水平的服务器进程。要非得说是工业级或者生产环境级别的吧,也算是,毕竟bugfix的代码的体量是玩具项目比不了的。而且,为了更好地bugfix,通常会引入lua或者python,然后游戏逻辑全盘由脚本构建,这下更方便bugfix了,还是hotfix的,那开发期就更能随便写写写了,你说架构是什么东西?

    至于具体拓扑,可以对着下图脑补一下,增加N个节点,N个节点之间互相连接。

    太原达内php培训班

    玩具水平的项目再修修补补,也永远不会变成工艺品。

    skynet别的不说,至少实现了一套轻量级的actor model,做服务分离更自然,服务间的拓扑一目了然,连接拓扑更是优雅。网易的mobile_server,说实话我真的看不出跟bigworld早期版本有什么区别,连接拓扑一塌糊涂,完全没有服务的概念,手游时代了强推这种架构,即使成了几款过亿流水又怎样?

    大网易的游戏开发应届生招聘要求精通分布式系统设计,就mobile_server写出来的玩具也好意思说是“分布式系统”?

    很多游戏服务端程序员,在游戏服务端开发生涯结束之前,其接触的,或者能接受的设计基本到此为止。如果是纯MMO手游,这样做没什么,毕竟十几年都这样过来了,开发成本更重要。更搞笑的是社交游戏、异步战斗的卡牌游戏也用mobile_server,真搞不明白怎么想的。

    大部分游戏服务端实现中,服务器进程是原子单位。进程与进程之间的消息流建立的成本很低,结果就是服务端中很多进程互相之间形成了O(n^2)的连接数量。

    这样的话会有什么问题?

    一方面,连接拓扑关系很复杂。一种治标不治本的方法是抬高添加新进程的成本,比如如非必要上面不会允许你增加额外进程,这样更深度的解耦合就成了幻想。

    另一方面,游戏服务端的应用层与连接层难以分离。举个例子,在这种设计思路下,两个进程有没有连接是一种不确定态,设计的时候觉得没有,结果某个需求来了,不建立连接就很难实现。这样对于应用层来说,就需要提供连接的概念,某个进程必须先跟其他进程连接建立成功了,然后才能调用其他进程提供的服务。而实际上,更优雅的设计是应用层完全不关注连接细节,只需要知道其他的进程提供了服务,自己就能获取到这种服务。

    这样,我们就需要在游戏服务端中提供服务的概念。场景同步服务是一种服务,聊天服务是另一种服务。基于这个思路,我们继续探讨服务应该如何定义,服务有哪些类型,不同类型的服务的消息流应该是怎样的。

    3.2 Service-Oriented游戏服务端

    3.2.1 游戏服务端中的服务

    定义问题

    之前提到,传统MMO架构随发展逐渐出现了分拆的需求,最常见的是把聊天逻辑从全局进程中拆出来。

    这种拆分的思路是符合service-oriented的发展趋势的,仔细想想的话,其实聊天服务本来就应该是具体项目无关的。游戏中可以嵌入公司的公共聊天服务,甚至是第三方提供的聊天服务,比如网易最近开推的云信。http://netease.im/

    这样,聊天服务就是独立于游戏业务而持久存在的,我们就从代码复用的层次上升到了服务复用。诚然,公司内不同项目,也可以直接用同一套聊天服务代码库,达到代码级别的复用。但是这样做最后的结果往往就是,每个团队都会从更早的团队拿过来聊天业务代码,然后自己改造改造,成了完全不同的分支,最后连代码复用都做不到了。

    从另一个思路来讲,同一款游戏的不同组服务器,其实也只需要同样的一组聊天服务。但是如果按传统的模式,一组服务器只能开零或一个聊天服务器,事实上,有可能某10组服务器用1个聊天服务器就够了,而某1组服务器用1个聊天服务器压力都有些大。

    因此,我们可以定义服务的概念。

    在明确这个定义之前,你也许注意到了,我在文章的之前部分措词很混乱——一会儿是XX进程,一会儿是XX服务器,一会儿又是XX服务。现在,我们统称为XX服务(或XXservice)。

    比如,场景服务与切场景服务,聊天服务,公会服务等等。

    服务是什么?

    可以简单理解为一组方法集合。服务是分布式游戏服务端中的最小实体,一个服务提供了一组确定的、可供调用的方法。

    skynet中,一个skynet_context唯一对应一个服务,而一个skynet节点对应一组服务;传统MMO中,一个进程对应一组服务,但是很难在其中找到“一个”服务的划分界限。

    在确定如何划分服务之前,首先看看服务的类型。

    对于游戏服务端的需求来说,服务可以大概分为两类:一类是具有独立命名空间的;一类是在全局命名空间的。

    服务的命名空间其实也算是具有游戏开发特色的,虽然不知道最早MMO分服的具体原因是什么,但是就事实而言,ARPG游戏的分服已经成了策划需求。后来又是各种渠道服的需求出现,命名空间更是没办法丢掉。而且还有一点,就是开发阶段本地调试对隔离服务端环境的需求。

    举个例子,之前提到的聊天服务就是一种全局命名空间的服务,而对于分服游戏来说,场景服务就是具有独立命名空间的服务。而对于手游来说,可以划分出的服务就更多了。

    服务划分解决了什么问题?

    以进程为单位开发和服务为单位开发是两种不同的思路。人是有惰性的,如果不是特别必要,上面也没人强推,那我想大部分程序员还是会把聊天服务实现在全局协调进程里。

    服务的概念就是为了提出一种与物理容器无关的抽象。服务可以以某个进程为容器,也可以以某个线程为容器。可以像skynet一样以一个luaState为容器,也可以像Erlang游戏服务端那样以一个actor为容器。而一个容器也可以提供多种服务。

    注意,这里提出的服务这种抽象与之前所说的Gate这种基础设施抽象是不同的。如果将游戏服务端看做一个整体,那么Gate就是其中的static parts,服务就是其中的dynamic parts。两者解决的是不同层面的问题。

    服务划分的核心原则是将两组耦合性较低的逻辑划分为不同的服务。具体实现中肯定不存在完美的划分方案,因此作为让步,只要是互交互不多的逻辑都可以划分为不同的服务。举一个简单的例子就是公会服务v.s.场景服务,两者的关系并不是特别密切。

    引入新的问题

    服务划分的极端是每一个协议包都对应一种服务。事实上,服务的定义本来就是基本隔绝的逻辑集合。如果服务定义得太多,服务间数据交互就会复杂到程序员无法维护的程度。

    复杂数据交互的另一方面,是复杂的网络拓扑。基于我们之前的架构,client与服务的通信可以借助Gate简化模型,但是服务之间的通信却需要 O(n^2)的连接数。服务都是dynamic parts,却对其他服务的有无产生了依赖,而且大部分情况下这种依赖都是双向的。整个服务端的网络会错综复杂。

    3.2.2 游戏服务端中的Message Queue

    定义问题

    我们要解决的最关键的问题是:如果服务之间很容易就产生相互依赖,应该如何化简复杂的网络拓扑。如果说得实际一点,那就是让服务器组的启动流程与关闭流程更加优雅,同时保证正确性。

    skynet给我带来的思路是,服务与服务之间无需保持物理连接,而只需要借助自己寄宿的skynet与其他服务通信,相当于所有服务间的连接都是抽象的、虚拟的。skynet是整个集群中的static parts,服务作为dynamic parts启动顺序肯定在skynet之后。

    skynet可以大大简化服务间拓扑关系,但是其定位毕竟不在于此,比如,skynet并不做消息的qos保证,skynet也没有提供各种方便的外围设施。我们还需要提供更强大语义的基础设施抽象。

    面对这种需求,我们需要一种消息队列中间件。

    生产者消费者一直都是一种比较经典的解耦模型,而消息队列就是基于这种模型构建的。每个skynet节点本质上就是一个高度精简的消息队列,为寄宿的每个服务维护一个私有队列,对全局队列中的消息dispatch,驱动寄宿服务。

    而我希望的是更纯粹的消息队列中间件,选择有很多,下面以RabbitMQ为例简单介绍。

    RabbitMQ提供了消息队列中间件能提供的所有基本语义,比如消息的ack机制和confirm机制、qos保证、各种pattern的支持、权限控制、集群、高可用、甚至是现成的图形化监控等等。接下来的讨论会尽量不涉及RabbitMQ具体细节,把它当做一个通常的消息队列中间件来集成到我们目前为止形成的游戏服务端之中。当然,Gate经过扩展之后也能替代MQ,但是这样就失去了其作为Gate的意义——Gate更多的是用在性能敏感的场合,比如移动同步,协议太重是没有必要的。而且,重新造个MQ的轮子,说实话意义真的不大。

    MQ解决了什么问题?

    MQ与Gate的定位类似,都是整个生态中的static parts。但是MQ与Gate是两种不同的基础设施抽象,提供的语义也不尽相同。

    Gate要解决的问题是以最低的成本构建消息流模型,仅提供传输层所能提供的消息送到质量保证(TCP撕UDP暂时领先)。client与Gate的连接断开,Gate没有义务再保留连接上下文。Gate其实是在游戏场景同步需求情景下诞生的特殊的MQ,具有一部分MQ的职责,比如发布订阅(客户端发布,服务端订阅,带组播的话还支持message dup),协议高度简化(对比下AMQP协议的复杂度。。),没有一些MQ专有的capability(qos保证,消息持久化等)。

    MQ要解决的问题是提供普适的消息队列抽象。性能不敏感的服务可以依赖MQ构建,将自己的连接维护与会话保持两块状态寄存在MQ上。

    这样,我们的服务端中就出现了两个static parts——一个是Gate,一个是MQ。Gate与MQ是两个完全无关的基础设施,这两部分先于其他所有dynamic parts启动、构建。场景服务连接Gate与MQ(前提是确实有其他服务会与场景服务进行通信),聊天服务连接MQ,client连接Gate与MQ。

    引入MQ之后的拓扑:

    太原达内php编程开发

    再脑补一下,增加N个节点,就形成了Gate和MQ的双中心,网络拓扑优雅了很多。

    就具体实现来说,之所以选择RabbitMQ,还因为其对mqtt协议支持的比较好,官网上就有插件下载。mqtt协议可以参考这里。client走mqtt协议跟MQ通信还是比较轻量级的。

    引入新的问题

    现在,client或者服务都需要通过不同的协议(Gate、MQ)与其他部分通信。

    这样对应用层开发者来说就是一个负担。

    服务端和客户端,走Gate的流程都是基于私有协议与自有的API。

    同时,在客户端,走MQ的流程基于mqtt协议与mqttLib的API;在服务端,走MQ的流程基于amqp协议与rabbitMQ的API。

    ps. Gate的私有协议和mqtt、amqp协议下面会统称为消息路由协议。

    而且不同的API的调用模型都不一样,因此我们需要一种应用层统一的调用规范。

    3.3 游戏服务端中的RPC与Pattern

    3.3.1 RPC

    定义问题

    整理一下现状。

    目前,client可以发送两类消息:一类交由Gate路由,一类交由MQ路由。service也可以接收两类消息:一类由Gate路由过来,一类由MQ路由过来。

    我们希望的是,应用层只需要关心服务,也就是说发送的消息是希望转到哪个服务上,以及接收的消息是请求自己提供的哪个服务。

    这样对于应用层来说,其看到的协议应该是统一的,而至于应用层协议的底层协议是Gate的协议还是MQ的协议,由具体的适配器(Adaptor)适配。

    这个应用层的协议就是RPC的一部分。

    RPC一直都是很有争议的。一方面,它能让代码看起来更优雅,省了不少打解包的重复代码;另一方面,程序员能调RPC了,系统就变得很不可控,特别是像某些架构下面RPC底层会绕很多,最后用的时候完全违背设计本意。

    但是总的来说,RPC的优势还是比较明显的,毕竟游戏服务端的整体服务定义都是同一个项目组内做的,副作用严格可控,很少会出现调用一条RPC要绕很多个节点的情况。

    RPC解决什么样的问题?

    RPC的定位是具体消息路由协议与应用层函数调用的中间层。一个标准的RPC框架要解决两个问题:

    第一是协议定义。

    第二是调用规范的确立。

    RPC的协议定义也可以做个划分:

    协议中的一部分用来标识一次调用session,可以用来实现RPC的回调,可以用来实现RPC的超时管理等等。

    另一部分用来标识调用的具体方法。这部分其实跟用不用RPC没太大关系,因为不用RPC只是打解包的话也是会用一些协议序列化、反序列化协议包的。采用RPC框架的话,就是希望这部分工作尽可能多的自动化。

    RPC调用规范的核心设计意图就是让应用层程序员调用起来非常自然、不需要有太多包袱(类bigworld架构的rpc设计通常也是这个原则,尽量让应用层不关注切进程的细节)。调用规范的具体细节就跟语言和平台相关了。在支持异步语法的语言/平台,可以原生集成异步等待、执行完恢复上下文继续执行的语义。在不支持异步语法的语言/平台,那就只能callback。如果是不支持将函数作为参数传递的语言/平台,我想你应该已经离现代游戏开发太远了。

    通用的部分确定之后,还得解决特定于具体路由方式的、需要适配的部分。

    我将这部分逻辑称为Adaptor,很好理解,就是RPC到具体消息路由协议、具体消息路由协议到RPC的适配器。

    下面,结合一种具体的RPC实现方式(下文称为Phial规范),来探讨下如何将上面提出的这几个概念串起来。

    先通过一个大概的流程来厘清一次RPC流程中涉及的所有角色。

    RPC既然作为一次远程过程调用,那么,对于调用方来说,其调用的是一个跟普通函数很像的函数(有可能表现为一个异步函数,也有可能表现为一个同步函数);对于被调用方来说,其被调用的就真的是自己的一个函数了。

    整个的pipeline也很清晰:

    调用方调用某个服务的某个函数,RPC层会根据之前说的RPC层协议将调用信息(invokeId、方法id、参数等)打包,并将打包的消息和函数对应服务的路由规则告诉路由适配层,路由适配层根据路由规则给打包消息加个消息头,然后传给路由层(具体的Gate路由或MQ路由)。

    路由层将消息路由到对应节点,该节点上的路由适配层解出消息头和打包消息,根据消息头确定被请求服务,并这些信息传给RPC层,RPC层解打包消息得到调用信息,然后做一次dispatch,被调用方的一开始注册进来的对应函数就会被回调到了。

    在这个过程中,我们称调用方可以调用的是服务的delegate(可以类比为Stub),被调用方注册进来的是服务的implement(可以类比为Skeleton)。路由适配层就是Adaptor。可以基于不同类型的Adaptor构造服务的delegate。服务的implement也可以注册在不同的Adaptor上。不同的Adaptor只需要针对RPC层提供同样的接口,让RPC层可以发送打包消息和服务特定的路由规则,可以注册implement即可保证RPC层与Adaptor层是完全无关的。

    我们在示例中实现了多种Adaptor,目前为止涉及到的有MqttAdaptor、GateAdaptor、AmqpAdaptor。

    除了这整个的数据流之外,示例中还包装了两种异步调用与回调形式。

    一种是针对.Net 2.0的callback模式;

    一种是针对.Net 4.5的Task await/async模式。

    第一种专门针对不支持.Net 4.5的平台,比如Unity。但是只要针对这种形式稍加扩展,也能支持.Net 2.0的yield语义,实现简单协程。关于.Net 2.0中的协程实现,可以参考这里。

    两种异步方式实现回调的原理是相同的,都是本地hold住调用上下文,等回包的时候检查即可。

    这样,在支持.Net 4.5的平台,一个穿插了RPC调用的函数就可以写成这个样子:

    太原达内科技

    在Unity中的脚本逻辑,可以这样调用RPC:

    太原达内php编程

    关于一些细节的说明

    我在之前的流程里面特意没有说明打包协议,打包协议选择很多,比如msgpack、bson、pb、pbc等等。示例实现中采用的是一种顺序的二进制打解包机制,缺点就是没办法做版本兼容,优点就是实现起来简单速度快。当然换打包协议也是很容易的。示例项目后续会增加对多种打包协议的支持。

    由于这个RPC框架主要是针对unity游戏,客户端部分与服务端部分的平台本质是不同的,客户端以.Net 2.0为基础,服务端以.Net 4.5为基础。相关的服务定义文件也都隔离成了两个库,既减少了对客户端的协议暴露,又可以保证客户端依赖库的体积最小。

    Adaptor的接口设计。Adaptor是为RPC层服务的,因此不同的Adaptor所需要实现的接口只需要面向RPC层保持一致。Adaptor需要针对delegate与implement提供不同的抽象意义。对于implement来说,Adaptor是一个持续产出消息的流;对于delegate来说,Adaptor是一个可以接受消息的传输器。应用层对自己掌握的Adaptor是知情的,因此Adaptor可以提供特化的接口,比如client需要的所有Adaptor都需要额外提供Poll接口,场景服务需要的GateAdaptor也需要Poll接口。

    引入新的问题

    有了RPC之后,我们可以在应用层以统一的形式进行服务请求。

    但是这样还不够——我们目前所提的RPC就是普通的方法调用,虽然对应用层完全隐藏了协议或者其他中间件的细节,但是这样一来这些中间件的强大特性我们也就无法利用了。

    还应该有另一种与RPC平行的抽象来特化RPC的形式,这种抽象与RPC共同组成了一种游戏开发规范。

    3.3.2 RPC、Pattern与规范

    定义问题

    由于不同的中间件解决问题的方式不同,因此我们没办法在应用层用统一的形式引用不同的中间件。因此,我们可以针对游戏开发中的一些比较经典的消息pipeline,定义pattern。然后,用pattern与RPC共同描述服务应该如何声明,如何被调用。

    Pattern解决了什么问题

    pattern规定了客户端与服务、服务与服务的有限种交互形式。

    pattern解决了之前我们只能靠感觉确定服务应该走哪种基础设施抽象的问题。

    不同的基础设施抽象可以实现不同的pattern子集,如果需要新增加一类基础设施,我们可以看它的功能分别可以映射到哪几种pattern上,这样就能直接集成到Phial规范中。

    下面,就针对游戏服务端的常见需求,定义几种pattern。

    三种通信情景:

    client -> server

    最简单的pattern是ask,也就是向服务发起一次异步调用,然后client不关注服务的处理结果就直接进行后续的逻辑。最常见的就是移动请求。

    还有一种是传统MMO中不太重视,而异步交互手游反倒从web引入的request。client向服务发起一次异步调用,但是会等到服务处理结果返回(或超时)才进行后续的逻辑。例子比较多,比如一次抽卡或者一次异步PVP。

    server -> client

    与ask对应的是sync,是服务进行一次无源的对client的impl调用,client无条件执行impl逻辑。sync需要指明被调用方。这种最常见的是移动同步。有一点需要注意,示例中实现了一种形式比较丑陋的组播sync,依赖了Gate的私有协议,也就是forward指定一个int值。这个之后会做调整。

    与request对应的是reply。这个相当于是处理一次request然后直接返回一个值,没什么特别之处。

    server -> server

    最常见的就是invoke,相当于一次希望返回值的远程调用。例子有很多,适用于任意两个服务间的通信需求。

    还有一种解耦利器我称之为notify。当然本质上其实就是pub-sub,消息会在中间件上dup。应用情景是消息提供者/事件源只管raise event,而不关注event是否被处理、event后续会被路由到哪里。在中间件上,只要有服务实现了该notify service的impl,就能得到通知;如果没有任何节点提供对该服务的impl,就相当于消息被推到了sink。应用情景是可以将玩家行为log以及各种监控、统计系统逻辑从业务代码中剥离出来,事件源触发的逻辑只有一处,而处理的逻辑可以分散在其他监控进程中,不需要增加一种监控就得在每个事件源都对应插一行代码。

    Gate和MQ实现了不同的pattern集合。当然,正如之前所说,Gate本质上也是一种MQ,但是由于我们对这两种基础设施抽象的定位不同,所以在实现各自的Adaptor的时候也限定了各自支持的pattern。比如,Gate不能支持notify,MQ不能支持ask-sync。

    我在示例实现中没有加入MQ对客户端组播的支持。主要原因是考虑到client是通过MQTT协议跟MQ通信,相当于组维护是client发起的。对于聊天这种的可能还好,对于其他的可能会有隐患。

    引入新的问题

    到目前为止,我们总结出了如下几种与游戏服务端有关的消息pipeline:

    client -> Gate -> service

    service -> Gate -> client

    service -> Gate -> client*

    client -> MQ -> service

    service -> MQ -> client

    service -> MQ -> service

    service -> MQ -> service*

    这基本上已经能涵盖游戏中的大部分需求了,因此我们对消息流的讨论就到此为止。

    接下来讨论游戏世界的状态维护。

    维护游戏世界状态的职责同样由一种服务负责,这种服务下面称为数据服务。

    但是数据服务所说的服务与之前所提的作为dynamic parts的Phial服务不太相同,实际上是一些基础设施抽象和Phial服务的组合。

    有了数据服务,我们还可以更加明确client与service走Gate与MQ究竟有什么本质区别。

上一篇:太原php培训班:一个知乎重度用户眼中的知乎

下一篇:太原达内php培训班:游戏服务端究竟解决了什么问题?(二)

最新开班日期  |  更多

php高级开发名企定制班(剩2个名额)

php高级开发名企定制班(剩2个名额)

开班日期:12-30

php高级开发周末班(剩5个名额)

php高级开发周末班(剩5个名额)

开班日期:12-30

php高级开发免费试听(剩5个名额)

php高级开发免费试听(剩5个名额)

开班日期:12-30

更多高级开发工程师精品班

更多高级开发工程师精品班

开班日期:12-30

  • 地址:山西省太原市小店区学府街长治路高新国际A座24层
  • 课程培训电话:13623629309     全国服务监督电话:400-827-0010
  • 服务邮箱 ts@tedu.cn
  • 2001-2016 达内国际公司(TARENA INTERNATIONAL,INC.) 版权所有 京ICP证08000853号-56

    在线客服系统