一、引言

要實現一整套能用于大用戶量、高并發場景下的IM群聊，技術難度遠超IM系統中的其它功能，原因在于：IM群聊消息的實時寫擴散特性帶來了一系列技術難題。

舉個例子：如一個2000人群里，一條普通消息的發出問題，將瞬間寫擴散為2000條消息的接收問題，如何保證這些消息的及時、有序、高效地送達，涉及到的技術問題點實在太多，更別說個別場景下萬人大群里的炸群消息難題了更別說個別場景下萬人大群里的炸群消息難題了。

這也是為什么一般中大型IM系統中，都會將群聊單獨拎出來考慮架構的設計，單獨有針對性地進行架構優化，從而降低整個系統的設計難度。

本文將分享的是一套生產環境下的IM群聊消息系統的高可用、易伸縮、高并發架構設計實踐，屬于原創第一手資料，內容較專業，適合有一定IM架構經驗的后端程序員閱讀。

二、群聊技術文章

《IM群聊消息究竟是存1份(即擴散讀)還是存多份(即擴散寫)？》
《IM群聊消息的已讀回執功能該怎么實現？》
《關于IM即時通訊群聊消息的亂序問題討論》
《現代IM系統中聊天消息的同步和存儲方案探討》
《移動端IM中大規模群消息的推送如何保證效率、實時性？》
《微信后臺團隊：微信后臺異步消息隊列的優化升級實踐分享》
《IM群聊消息如此復雜，如何保證不丟不重？》
《IM單聊和群聊中的在線狀態同步應該用“推”還是“拉”？》
《如何保證IM實時消息的“時序性”與“一致性”？》
《快速裂變：見證微信強大后臺架構從0到1的演進歷程（一）》

三、萬事開頭難：初始的極簡實現

所謂的群聊消息系統，就是一種多對多群體聊天方式，譬如直播房間內的聊天室對應的服務器端就是一個群聊消息系統。

2017年9月初，我們初步實現了一套極簡的群聊消息系統，其大致架構如下：

系統名詞解釋：
?

• 1）Client :?消息發布者【或者叫做服務端群聊消息系統調用者】，publisher；
• 2）Proxy :?系統代理，對外統一接口，收集Client發來的消息轉發給Broker；
• 3）Broker ：系統消息轉發Server，Broker 會根據 Gateway Message 組織一個 RoomGatewayList【key為RoomID，value為 Gateway IP：Port 地址列表】，然后把 Proxy 發來的消息轉發到 Room 中所有成員登錄的所有 Gateway；
• 4）Router ：用戶登錄消息轉發者，把Gateway轉發來的用戶登入登出消息轉發給所有的Broker；
• 5）Gateway ：所有服務端的入口，接收合法客戶端的連接，并把客戶端的登錄登出消息通過Router轉發給所有的Broker；
• 6）Room Message :?Room聊天消息；
• 7）Gateway Message :?Room內某成員 登錄 或者 登出 某Gateway消息，包含用戶UIN/RoomID/Gateway地址{IP：Port}等消息。

當一個 Room 中多個 Client 連接一個 Gateway 的時候，Broker只會根據 RoomID 把房間內的消息轉發一次給這個Gateway，由Gateway再把消息復制多份分別發送給連接這個 Gateway 的 Room 中的所有用戶的客戶端。

這套系統有如下特點：
?

• 1）系統只轉發房間內的聊天消息，每個節點收到后立即轉發出去，不存儲任何房間內的聊天消息，不考慮消息丟失以及消息重復的問題；
• 2）系統固定地由一個Proxy、三個Broker和一個Router構成；
• 3）Proxy接收后端發送來的房間消息，然后按照一定的負載均衡算法把消息發往某個Broker，Broker則把消息發送到所有與Room有關系的接口機Gateway；
• 4）Router接收Gateway轉發來的某個Room內某成員在這個Gateway的登出或者登錄消息，然后把消息發送到所有Broker；
• 5）Broker收到Router轉發來的Gateway消息后，更新（添加或者刪除）與某Room相關的Gateway集合記錄；
• 6）整個系統的通信鏈路采用UDP通信方式。

從以上特點，整個消息系統足夠簡單，沒有考慮擴縮容問題，當系統負載到達極限的時候，就重新再部署一套系統以應對后端client的消息壓力。

這種處理方式本質是把系統的擴容能力甩鍋給了后端Client以及前端Gateway：每次擴容一個系統，所有Client需要在本地配置文件中添加一個Proxy地址然后全部重啟，所有Gateway則需要再本地配置文件添加一個Router地址然后全部重啟。

這種“幸福我一人，辛苦千萬家”的擴容應對方式，必然導致公司內部這套系統的使用者怨聲載道，下一階段的升級就是必然的了。

四、進一步重點設計：“可擴展性”

?

4.1、基本思路

大道之行也，天下為公，不同的系統有不同的構架，相同的系統總有類似的實現。類似于數據庫的分庫分表【關于分庫分表，目前看到的最好的文章是《一種支持自由規劃無須數據遷移和修改路由代碼的Replicaing擴容方案》】，其擴展實現核心思想是分Partition分Replica，但各Replica之間還區分leader（leader-follower，只有leader可接受寫請求）和non-leader（所有replica均可接收寫請求）兩種機制。

從數據角度來看，這套系統接收兩種消息：Room Message（房間聊天消息）和Gateway Message（用戶登錄消息）。兩種消息的交匯之地就是Broker，所以應對擴展的緊要地方就是Broker，Broker的每個Partition采用non-leader機制，各replica均可接收Gateway Message消息寫請求和Room Message轉發請求。

首先，當Room Message量加大時可以對Proxy進行水平擴展，多部署Proxy即可因應Room Message的流量。

其次，當Gateway Message量加大時可以對Router進行水平擴展，多部署Router即可因應Gateway Message的流量。

最后，兩種消息的交匯之地Broker如何擴展呢？可以把若干Broker Replica組成一個Partition，因為Gateway Message是在一個Partition內廣播的，所有Broker Replica都會有相同的RoomGatewayList 數據，因此當Gateway Message增加時擴容Partition即可。當Room Message量增加時，水平擴容Partition內的Broker Replica即可，因為Room Message只會發送到Partition內某個Replica上。

從個人經驗來看，Room ID的增長以及Room內成員的增加量在一段時間內可以認為是直線增加，而Room Message可能會以指數級增長，所以若設計得當則Partition擴容的概率很小，而Partition內Replica水平增長的概率幾乎是100%。

不管是Partition級別的水平擴容還是Partition Replica級別的水平擴容，不可能像系統極簡版本那樣每次擴容后都需要Client或者Gateway去更新配置文件然后重啟，因應之道就是可用zookeeper充當角色的Registriy。通過這個zookeeper注冊中心，相關角色擴容的時候在Registry注冊后，與之相關的其他模塊得到通知即可獲取其地址等信息。采用zookeeper作為Registry的時候，所以程序實現的時候采用實時watch和定時輪詢的策略保證數據可靠性，因為一旦網絡有任何的抖動，zk就會認為客戶端已經宕機把鏈接關閉。

分析完畢，與之相對的架構圖如下：

以下各分章節將描述各個模塊詳細流程。

4.2、Client

Client詳細流程如下：
?

• 1）從配置文件加載Registry地址；
• 2）從Registy上Proxy注冊路徑/pubsub/proxy下獲取所有的Proxy，依據各個Proxy ID大小順序遞增組成一個ProxyArray；
• 3）啟動一個線程實時關注Registry路徑/pubsub/proxy，以獲取Proxy的動態變化，及時更新ProxyArray；
• 4）啟動一個線程定時輪詢獲取Registry路徑/pubsub/proxy下各個Proxy實例，作為關注策略的補充，以期本地ProxyArray內各個Proxy成員與Registry上的各個Proxy保持一致；定時給各個Proxy發送心跳，異步獲取心跳回包；定時清除ProxyArray中心跳超時的Proxy成員；
• 5）發送消息的時候采用snowflake算法給每個消息分配一個MessageID，然后采用相關負載均衡算法把消息轉發給某個Proxy。

?

4.3、Proxy

Proxy詳細流程如下：
?

• 1）讀取配置文件，獲取Registry地址；
• 2）把自身信息注冊到Registry路徑/pubsub/proxy下，把Registry返回的ReplicaID作為自身ID；
• 3）從Registry路徑/pubsub/broker/partition(x)下獲取每個Broker Partition的各個replica；
• 4）從Registry路徑/pubsub/broker/partition_num獲取當前有效的Broker Partition Number；

?

• 5）啟動一個線程關注Registry上的Broker路徑/pubsub/broker，以實時獲取以下信息：
• ? ? {Broker Partition Number}
• ? ???- 新的Broker Partition（此時發生了擴容）；
• ? ???- Broker Partition內新的broker replica（Partition內發生了replica擴容）；
• ? ???- Broker Parition內某replica掛掉的信息；

?

• 6）定時向各個Broker Partition replica發送心跳，異步等待Broker返回的心跳響應包，以探測其活性，以保證不向超時的replica轉發Room Message；
• 7）啟動一個線程定時讀取Registry上的Broker路徑/pubsub/broker下各個子節點的值，以定時輪詢的策略觀察Broker Partition Number變動，以及各Partition的變動情況，作為實時策略的補充；同時定時檢查心跳包超時的Broker，從有效的BrokerList中刪除；
• 8）依據規則【BrokerPartitionID = RoomID % BrokerPartitionNum， BrokerReplicaID = RoomID % BrokerPartitionReplicaNum】向某個Partition的replica轉發Room Message，收到Client的Heatbeat包時要及時給予響應。

之所以把Room Message和Heartbeat Message放在一個線程處理，是為了防止進程假死這種情況。

當/pubsub/broker/partition_num的值發生改變的時候(譬如值改為4)，意味著Router Partition進行了擴展，Proxy要及時獲取新Partition路徑（如/pubsub/broker/Partition2和/pubsub/broker/Partition3）下的實例，并關注這些路徑，獲取新Partition下的實例。

之所以Proxy在獲取Registry下所有當前的Broker實例信息后再注冊自身信息，是因為此時它才具有轉發消息的資格。

Proxy轉發某個Room消息時候，只發送給處于Running狀態的Broker。為Broker Partition內所有replica依據Registry給其分配的replicaID進行遞增排序，組成一個Broker Partition Replica Array，規則中BrokerPartitionReplicaNum為Array的size，而BrokerReplicaID為replica在Array中的下標。

4.4、Pipeline

收到的 Room Message 需要做三部工作：收取 Room Message、消息協議轉換和向 Broker 發送消息。

初始系統這三步流程如果均放在一個線程內處理，proxy 的整體吞吐率只有 50 000 Msg/s。

最后的實現方式是按照消息處理的三個步驟以 pipeline 方式做如下流程處理：
?

• 1）啟動 1 個消息接收線程和 N【N == Broker Parition 數目】個多寫一讀形式的無鎖隊列【稱之為消息協議轉換隊列】，消息接收線程分別啟動一個 epoll 循環流程收取消息，然后把消息以相應的 hash 算法【隊列ID = UIN % N】寫入對應的消息協議轉換隊列；
• 2）啟動 N 個線程 和 N * 3 個一寫一讀的無鎖隊列【稱之為消息發送隊列】，每個消息協議專家線程從消息協議轉換隊列接收到消息并進行協議轉換后，根據相應的 hash 算法【隊列ID = UIN % 3N】寫入消息發送隊列；
• 3）啟動 3N 個消息發送線程，分別創建與之對應的 Broker 的連接，每個線程單獨從對應的某個消息發送隊列接收消息然后發送出去。

經過以上流水線改造后，Proxy 的整體吞吐率可達 200 000 Msg/s。

關于 pipeline 自身的解釋，本文不做詳述，可以參考下圖：

4.5、大房間消息處理

每個 Room 的人數不均，最簡便的解決方法就是給不同人數量級的 Room 各搭建一套消息系統，不用修改任何代碼。

然所謂需求推動架構改進，在系統迭代升級過程中遇到了這樣一個需求：業務方有一個全國 Room，用于給所有在線用戶進行消息推送。針對這個需求，不可能為了一個這樣的 Room 單獨搭建一套系統，況且這個 Room 的消息量很少。

如果把這個 Room 的消息直接發送給現有系統，它有可能影響其他 Room 的消息發送：消息系統是一個寫放大的系統，全國 Room 內有系統所有的在線用戶，每次發送都會卡頓其他 Room 的消息發送。

最終的解決方案是：使用類似于分區的方法，把這樣的大 Room 映射為 64 個虛擬 Room【稱之為 VRoom】。在 Room 號段分配業務線的配合下，給消息系統專門保留了一個號段，用于這種大 Room 的切分，在 Proxy 層依據一個 hash 方法 【 VRoomID = UserID % 64】 把每個 User 分配到相應的 VRoom，其他模塊代碼不用修改即完成了大 Room 消息的路由。

4.6、Broker

Broker詳細流程如下：
?

• 1）Broker加載配置，獲取自身所在Partition的ID（假設為3）；
• 2）向Registry路徑/pubsub/broker/partition3注冊，設置其狀態為Init，注冊中心返回的ID作為自身的ID(replicaID)；
• 3）接收Router轉發來的Gateway Message，放入GatewayMessageQueue；
• 4）從Database加載數據，把自身所在的Broker Partition所應該負責的 RoomGatewayList 數據加載進來；
• 5）異步處理GatewayMessageQueue內的Gateway Message，只處理滿足規則【PartitionID == RoomID % PartitionNum】的消息，把數據存入本地路由信息緩存；
• 6）修改Registry路徑/pubsub/broker/partition3下自身節點的狀態為Running；
• 7）啟動線程實時關注Registry路徑/pubsub/broker/partition_num的值；
• 8）啟動線程定時查詢Registry路徑/pubsub/broker/partition_num的值；
• 9）當Registry路徑/pubsub/broker/partition_num的值發生改變的時候，依據規則【PartitionID == RoomID % PartitionNum】清洗本地路由信息緩存中每條數據；
• 10）接收Proxy發來的Room Message，依據RoomID從路由信息緩存中查找Room有成員登陸的所有Gateway，把消息轉發給這些Gateway。

注意Broker之所以先注冊然后再加載Database中的數據，是為了在加載數據的時候同時接收Router轉發來的Gateway Message，但是在數據加載完前這些受到的數據先被緩存起來，待所有 RoomGatewayList 數據加載完后就把這些數據重放一遍；

Broker之所以區分狀態，是為了在加載完畢 RoomGatewayList 數據前不對Proxy提供轉發消息的服務，同時也方便Broker Partition應對的消息量增大時進行水平擴展。

當Broker發生Partition擴展的時候，新的Partition個數必須是2的冪，只有新Partition內所有Broker Replica都加載實例完畢，再更改/pubsub/broker/partition_num的值。

老的Broker也要watch路徑/pubsub/broker/partition_num的值，當這個值增加的時候，它也需要清洗本地的路由信息緩存。

Broker的擴容過程猶如細胞分裂，形成中的兩個細胞有著完全相同的數據，分裂完成后【Registry路徑/pubsub/broker/partition_num的值翻倍】則需要清洗垃圾信息。這種方法稱為翻倍法。

4.7、Router

Router詳細流程如下：
?

• 1）Router加載配置，Registry地址；
• 2）把自身信息注冊到Registry路徑/pubsub/router下，把Registry返回的ReplicaID作為自身ID；
• 3）從Registry路徑/pubsub/broker/partition(x)下獲取每個Broker Partition的各個replica；
• 4）從Registry路徑/pubsub/broker/partition_num獲取當前有效的Broker Partition Number；

?

• 5）啟動一個線程關注Registry上的Broker路徑/pubsub/broker，以實時獲取以下信息：
• ? ? {Broker Partition Number}
• ? ? - 新的Broker Partition（此時發生了擴容）；
• ? ? - Broker Partition內新的broker replica（Partition內發生了replica擴容）；
• ? ? - Broker Parition內某replica掛掉的信息；

?

• 6）定時向各個Broker Partition replica發送心跳，異步等待Broker返回的心跳響應包，以探測其活性，以保證不向超時的replica轉發Gateway Message；
• 7）啟動一個線程定時讀取Registry上的Broker路徑/pubsub/broker下各個子節點的值，以定時輪詢的策略觀察Broker Partition Number變動，以及各Partition的變動情況，作為實時策略的補充；同時定時檢查心跳包超時的Broker，從有效的BrokerList中刪除；
• 8）從Database全量加載路由 RoomGatewayList 數據放入本地緩存；
• 9）收取Gateway發來的心跳消息，及時返回ack包；
• 10）收取Gateway轉發來的Gateway Message，按照一定規則【BrokerPartitionID % BrokerPartitionNum = RoomID % BrokerPartitionNum】轉發給某個Broker Partition下所有Broker Replica，保證Partition下所有replica擁有同樣的路由 RoomGatewayList 數據，再把Message內數據存入本地緩存，當檢測到數據不重復的時候把數據異步寫入Database。

?

4.8、Gateway

Gateway詳細流程如下：
?

• 1）讀取配置文件，加載Registry地址；
• 2）從Registry路徑/pubsub/router/下獲取所有router replica，依據各Replica的ID遞增排序組成replica數組RouterArray；
• 3）啟動一個線程實時關注Registry路徑/pubsub/router，以獲取Router的動態變化，及時更新RouterArray；
• 4）啟動一個線程定時輪詢獲取Registry路徑/pubsub/router下各個Router實例，作為關注策略的補充，以期本地RouterArray及時更新；定時給各個Router發送心跳，異步獲取心跳回包；定時清除RouterArray中心跳超時的Router成員；
• 5）當有Room內某成員客戶端連接上來或者Room內所有成員都不連接當前Gateway節點時，依據規則【RouterArrayIndex = RoomID % RouterNum】向某個Router發送Gateway Message；
• 6）收到Broker轉發來的Room Message時，根據MessageID進行去重，如果不重復則把消息發送到連接到當前Gateway的Room內所有客戶端，同時把MessageID緩存起來以用于去重判斷。

Gateway本地有一個基于共享內存的LRU Cache，存儲最近一段時間發送的消息的MessageID。

五、接下來迫切要解決的：系統穩定性

系統具有了可擴展性僅僅是系統可用的初步，整個系統要保證最低粒度的SLA（0.99），就必須在兩個維度對系統的可靠性就行感知：消息延遲和系統內部組件的高可用。

5.1、消息延遲

準確的消息延遲的統計，通用的做法可以基于日志系統對系統所有消息或者以一定概率抽樣后進行統計，但限于人力目前沒有這樣做。

目前使用了一個方法：通過一種構造一組偽用戶ID，定時地把消息發送給proxy，每條消息經過一層就把在這層的進入時間和發出時間以及組件自身的一些信息填入消息，這組偽用戶的消息最終會被發送到一個偽Gateway端，偽Gateway對這些消息的信息進行歸并統計后，即可計算出當前系統的平均消息延遲時間。

通過所有消息的平均延遲可以評估系統的整體性能。同時，因為系統消息路由的哈希方式已知，當固定時間內偽Gateway沒有收到消息時，就把消息當做發送失敗，當某條鏈路失敗一定次數后就可以產生告警了。

5.2、高可用

上面的方法同時能夠檢測某個鏈路是否出問題，但是鏈路具體出問題的點無法判斷，且實時性無法保證。

為了保證各個組件的高可用，系統引入了另一種評估方法：每個層次都給后端組件發送心跳包，通過心跳包的延遲和成功率判斷其下一級組件的當前的可用狀態。

譬如proxy定時給每個Partition內每個broker發送心跳，可以依據心跳的成功率來快速判斷broker是否處于“假死”狀態（最近業務就遇到過broker進程還活著，但是對任何收到的消息都不處理的情況）。

同時依靠心跳包的延遲還可以判斷broker的處理能力，基于此延遲值可在同一Partition內多broker端進行負載均衡。

六、進一步優化：消息可靠性

公司內部內部原有一個走tcp通道的群聊消息系統，但是經過元旦一次大事故（幾乎全線崩潰）后，相關業務的一些重要消息改走這套基于UDP的群聊消息系統了。這些消息如服務端下達給客戶端的游戲動作指令，是不允許丟失的，但其特點是相對于聊天消息來說量非常小（單人1秒最多一個），所以需要在目前UDP鏈路傳遞消息的基礎之上再構建一個可靠消息鏈路。

國內某IM大廠的消息系統也是以UDP鏈路為基礎的（見《為什么QQ用的是UDP協議而不是TCP協議？》），他們的做法是消息重試加ack構建了可靠消息穩定傳輸鏈路。但是這種做法會降低系統的吞吐率，所以需要獨辟蹊徑。

UDP通信的本質就是偽裝的IP通信，TCP自身的穩定性無非是重傳、去重和ack，所以不考慮消息順序性的情況下可以通過重傳與去重來保證消息的可靠性。

基于目前系統的可靠消息傳輸流程如下：

• 1）Client給每個命令消息依據snowflake算法配置一個ID，復制三份，立即發送給不同的Proxy；
• 2）Proxy收到命令消息以后隨機發送給一個Broker；
• 3）Broker收到后傳輸給Gateway；
• 4）Gateway接收到命令消息后根據消息ID進行重復判斷，如果重復則丟棄，否則就發送給APP，并緩存之。

正常的消息在群聊消息系統中傳輸時，Proxy會根據消息的Room ID傳遞給固定的Broker，以保證消息的有序性。

七、Router需要進一步強化

?

7.1、簡述

當線上需要部署多套群聊消息系統的時候，Gateway需要把同樣的Room Message復制多份轉發給多套群聊消息系統，會增大Gateway壓力，可以把Router單獨獨立部署，然后把Room Message向所有的群聊消息系統轉發。

Router系統原有流程是：Gateway按照Room ID把消息轉發給某個Router，然后Router把消息轉發給下游Broker實例。新部署一套群聊消息系統的時候，新系統Broker的schema需要通過一套約定機制通知Router，使得Router自身邏輯過于復雜。

重構后的Router架構參照上圖，也采用分Partition分Replica設計，Partition內部各Replica之間采用non-leader機制；各Router Replica不會主動把Gateway Message內容push給各Broker，而是各Broker主動通過心跳包形式向Router Partition內某個Replica注冊，而后此Replica才會把消息轉發到這個Broker上。

類似于Broker，Router Partition也以2倍擴容方式進行Partition水平擴展，并通過一定機制保證擴容或者Partition內部各個實例停止運行或者新啟動時，盡力保證數據的一致性。

Router Replica收到Gateway Message后，replica先把Gateway Message轉發給Partition內各個peer replica，然后再轉發給各個訂閱者。Router轉發消息的同時異步把消息數據寫入Database。

獨立Router架構下，下面小節將分別詳述Gateway、Router和Broker三個相關模塊的詳細流程。

7.2、Gateway

Gateway詳細流程如下：
?

• 1）從Registry路徑/pubsub/router/partition(x)下獲取每個Partition的各個replica；
• 2）從Registry路徑/pubsub/router/partition_num獲取當前有效的Router Partition Number；
• 3）啟動一個線程關注Registry上的Router路徑/pubsub/router，以實時獲取以下信息：{Router Partition Number} -> 新的Router Partition（此時發生了擴容）；??Partition內新的replica（Partition內發生了replica擴容）；??Parition內某replica掛掉的信息；
• 4）定時向各個Partition replica發送心跳，異步等待Router返回的心跳響應包，以探測其活性，以保證不向超時的replica轉發Gateway Message；
• 5）啟動一個線程定時讀取Registry上的Router路徑/pubsub/router下各個子節點的值，以定時輪詢的策略觀察Router Partition Number變動，以及各Partition的變動情況，作為實時策略的補充；同時定時檢查心跳包超時的Router，從有效的BrokerList中刪除；
• 6 依據規則向某個Partition的replica轉發Gateway Message。

第六步的規則決定了Gateway Message的目的Partition和replica，規則內容有：

如果某Router Partition ID滿足condition(RoomID % RouterPartitionNumber == RouterPartitionID % RouterPartitionNumber)，則把消息轉發到此Partition；

這里之所以不采用直接hash方式(RouterPartitionID = RoomID % RouterPartitionNumber)獲取Router Partition，是考慮到當Router進行2倍擴容的時候當所有新的Partition的所有Replica都啟動完畢且數據一致時才會修改Registry路徑/pubsub/router/partitionnum的值，按照規則的計算公式才能保證新Partition的各個Replica在啟動過程中就可以得到Gateway Message，也即此時每個Gateway Message會被發送到兩個Router Partition。 當Router擴容完畢，修改Registry路徑/pubsub/router/partitionnum的值后，此時新集群進入穩定期，每個Gateway Message只會被發送固定的一個Partition，condition(RoomID % RouterPartitionNumber == RouterPartitionID % RouterPartitionNumber)等效于condition(RouterPartitionID = RoomID % RouterPartitionNumber)。

如果Router Partition內某replia滿足condition(replicaPartitionID = RoomID % RouterPartitionReplicaNumber)，則把消息轉發到此replica。

replica向Registry注冊的時候得到的ID稱之為replicaID，Router Parition內所有replica按照replicaID遞增排序組成replica數組RouterPartitionReplicaArray，replicaPartitionID即為replica在數組中的下標。

Gateway Message數據一致性：

Gateway向Router發送的Router Message內容有兩種：某user在當前Gateway上進入某Room 和 某user在當前Gateway上退出某Room，數據項分別是UIN（用戶ID）、Room ID、Gateway Addr和User Action(Login or Logout。

由于所有消息都是走UDP鏈路進行轉發，則這些消息的順序就有可能亂序。Gateway可以統一給其發出的所有消息分配一個全局遞增的ID【下文稱為GatewayMsgID，Gateway Message ID】以保證消息的唯一性和全局有序性。

Gateway向Registry注冊臨時有序節點時，Registry會給Gateway分配一個ID，Gateway可以用這個ID作為自身的Instance ID【假設這個ID上限是65535】。

GatewayMsgID字長是64bit，其格式如下：

1 2	// 63 -------------------------- 48 47 -------------- 38 37 ------------ 0 // |? 16bit Gateway Instance ID??? |?? 10bit Reserve??? |??? 38bit自增碼? |

?

7.3、Router

Router系統部署之前，先設置Registry路徑/pubsub/router/partition_num的值為1。

Router詳細流程如下：
?

• 1）Router加載配置，獲取自身所在Partition的ID（假設為3）；
• 2）向Registry路徑/pubsub/router/partition3注冊，設置其狀態為Init，注冊中心返回的ID作為自身的ID(replicaID)；
• 3）注冊完畢會收到Gateway發來的Gateway Message以及Broker發來的心跳消息（HeartBeat Message），先緩存到消息隊列MessageQueue；
• 4）從Registry路徑/pubsub/router/partition3下獲取自身所在的Partition內的各個replica；
• 5）從Registry路徑/pubsub/router/partition_num獲取當前有效的Router Partition Number；
• 6）啟動一個線程關注Registry路徑/pubsub/router，以實時獲取以下信息：{Router Partition Number}??-> Partition內新的replica（Partition內發生了replica擴容）；??Parition內某replica掛掉的信息；
• 7）從Database加載數據；
• 8）啟動一個線程異步處理MessageQueue內的Gateway Message，把Gateway Message轉發給同Partition內其他peer replica，然后依據規則【RoomID % BrokerPartitionNumber == BrokerReplicaPartitionID % BrokerPartitionNumber】轉發給BrokerList內每個Broker；處理Broker發來的心跳包，把Broker的信息存入本地BrokerList，然后給Broker發送回包；
• 9）修改Registry路徑/pubsub/router/partition3下節點的狀態為Running；
• 10）啟動一個線程定時讀取Registry路徑/pubsub/router下各個子路徑的值，以定時輪詢的策略觀察Router各Partition的變動情況，作為實時策略的補充；檢查超時的Broker，把其從BrokerList中剔除；
• 11）當RouterPartitionNum倍增時，Router依據規則【RoomID % BrokerPartitionNumber == BrokerReplicaPartitionID % BrokerPartitionNumber】清洗自身路由信息緩存中數據；
• 12）Router本地存儲每個Gateway的最大GatewayMsgID，收到小于GatewayMsgID的Gateway Message可以丟棄不處理，否則就更新GatewayMsgID并根據上面邏輯進行處理。

之所以把Gateway Message和Heartbeat Message放在一個線程處理，是為了防止進程假死這種情況。

Broker也采用了分Partition分Replica機制，所以向Broker轉發Gateway Message時候路由規則，與Gateway向Router轉發消息的路由規則相同。

另外啟動一個工具，當水平擴展后新啟動的Partition內所有Replica的狀態都是Running的時候，修改Registry路徑/pubsub/router/partition_num的值為所有Partition的數目。

7.4、Broker

Broker詳細流程如下：
?

• 1）Broker加載配置，獲取自身所在Partition的ID（假設為3）；
• 2）向Registry路徑/pubsub/broker/partition3注冊，設置其狀態為Init，注冊中心返回的ID作為自身的ID(replicaID)；
• 3）從Registry路徑/pubsub/router/partition_num獲取當前有效的Router Partition Number；
• 4）從Registry路徑/pubsub/router/partition(x)下獲取每個Router Partition的各個replica；
• 5）啟動一個線程關注Registry路徑/pubsub/router，以實時獲取以下信息：{Router Partition Number} -> 新的Router Partition（此時發生了擴容）；??Partition內新的replica（Partition內發生了replica擴容）；??Parition內某replica掛掉的信息；
• 6）依據規則【RouterPartitionID % BrokerPartitionNum == BrokerPartitionID % BrokerPartitionNum，RouterReplicaID = BrokerReplicaID % BrokerPartitionNum】選定目標Router Partition下某個Router replica，向其發送心跳消息，包含BrokerPartitionNum、BrokerPartitionID、BrokerHostAddr和精確到秒級的Timestamp，并異步等待所有Router replica的回復，所有Router轉發來的Gateway Message放入GatewayMessageQueue；
• 7）依據規則【BrokerPartitionID == RoomID % BrokerParitionNum】從Database加載數據；
• 8）依據規則【BrokerPartitionID % BrokerParitionNum == RoomID % BrokerParitionNum】異步處理GatewayMessageQueue內的Gateway Message，只留下合乎規則的消息的數據；
• 9）修改Registry路徑/pubsub/broker/partition3下自身節點的狀態為Running；
• 10）啟動一個線程定時讀取Registry路徑/pubsub/router下各個子路徑的值，以定時輪詢的策略觀察Router各Partition的變動情況，作為實時策略的補充；定時檢查超時的Router，某Router超時后更換其所在的Partition內其他Router替換之，定時發送心跳包；
• 11）當Registry路徑/pubsub/broker/partition_num的值BrokerPartitionNum發生改變的時候，依據規則【PartitionID == RoomID % PartitionNum】清洗本地路由信息緩存中每條數據；
• 12）接收Proxy發來的Room Message，依據RoomID從路由信息緩存中查找Room有成員登陸的所有Gateway，把消息轉發給這些Gateway；
• 13）Broker本地存儲每個Gateway的最大GatewayMsgID，收到小于GatewayMsgID的Gateway Message可以丟棄不處理，否則更新GatewayMsgID并根據上面邏輯進行處理。

BrokerPartitionNumber可以小于或者等于或者大于RouterPartitionNumber，兩個數應該均是2的冪，兩個集群可以分別進行擴展，互不影響。譬如BrokerPartitionNumber=4而RouterPartitionNumber=2，則Broker Partition 3只需要向Router Partition 1的某個follower發送心跳消息即可；若BrokerPartitionNumber=4而RouterPartitionNumber=8，則Broker Partition 3需要向Router Partition 3的某個follower發送心跳消息的同時，還需要向Router Partition 7的某個follower發送心跳，以獲取全量的Gateway Message。

Broker需要關注/pubsub/router/partitionnum和/pubsub/broker/partitionnum的值的變化，當router或者broker進行parition水平擴展的時候，Broker需要及時重新構建與Router之間的對應關系，及時變動發送心跳的Router Replica對象【RouterPartitionID = BrokerReplicaID % RouterPartitionNum，RouterPartitionID為Router Replica在PartitionRouterReplicaArray數組的下標】。

當Router Partition內replica死掉或者發送心跳包的replica對象死掉（無論是注冊中心通知還是心跳包超時），broker要及時變動發送心跳的Router replica對象。

另外，Gateway使用UDP通信方式向Router發送Gateway Message，如若這個Message丟失則此Gateway上該Room內所有成員一段時間內（當有新的成員在當前Gateway上加入Room 時會產生新的Gateway Message）都無法再接收消息，為了保證消息的可靠性，可以使用這樣一個約束解決問題：在此Gateway上登錄的某Room內的人數少于3時，Gateway會把Gateway Message復制兩份非連續（如以10ms為時間間隔）重復發送給某個Partition leader。因Gateway Message消息處理的冪等性，重復Gateway Message并不會導致Room Message發送錯誤，只在極少概率的情況下會導致Gateway收到消息的時候Room內已經沒有成員在此Gateway登錄，此時Gateway會把消息丟棄不作處理。

傳遞實時消息群聊消息系統的Broker向特定Gateway轉發Room Message的時候，會帶上Room內在此Gateway上登錄的用戶列表，Gateway根據這個用戶列表下發消息時如果檢測到此用戶已經下線，在放棄向此用戶轉發消息的同時，還應該把此用戶已經下線的消息發送給Router，當Router把這個消息轉發給Broker后，Broker把此用戶從用戶列表中剔除。通過這種負反饋機制保證用戶狀態更新的及時性。

八、離線消息的處理

?

8.1、簡述

前期的系統只考慮了用戶在線情況下實時消息的傳遞，當用戶離線時其消息便無法獲取。

若系統考慮用戶離線消息傳遞，需要考慮如下因素：
?

• 1）消息固化：保證用戶上線時收到其離線期間的消息；
• 2）消息有序：離線消息和在線消息都在一個消息系統傳遞，給每個消息分配一個ID以區分消息先后順序，消息順序越靠后則ID愈大。

離線消息的存儲和傳輸，需要考慮用戶的狀態以及每條消息的發送狀態，整個消息核心鏈路流程會有大的重構。

新消息架構如下圖：

?

系統名詞解釋：
?

• 1）Pi : 消息ID存儲模塊，存儲每個人未發送的消息ID有序遞增集合；
• 2）Xiu : 消息存儲KV模塊，存儲每個人的消息，給每個消息分配ID，以ID為key，以消息內為value；
• 3）Gateway Message(HB) : 用戶登錄登出消息，包括APP保活定時心跳（Hearbeat）消息。

系統內部代號貔貅(貔貅者，雄貔雌貅)，源自上面兩個新模塊。

這個版本架構流程的核心思想為“消息ID與消息內容分離，消息與用戶狀態分離”。消息發送流程涉及到模塊 Client/Proxy/Pi/Xiu，消息推送流程則涉及到模塊 Pi/Xiu/Broker/Router/Gateway。

下面小節先細述Pi和Xiu的接口，然后再詳述發送和推送流程。

8.2、Xiu

Xiu模塊功能名稱是Message Storage，用戶緩存和固化消息，并給消息分配ID。Xiu 集群采用分 Partition 分 Replica 機制，Partition 初始數目須是2的倍數，集群擴容時采用翻倍法。
?

8.2.1存儲消息

存儲消息請求的參數列表為{SnowflakeID，UIN, Message}，其流程如下：
?

• 1）接收客戶端發來的消息，獲取消息接收人ID（UIN）和客戶端給消息分配的 SnowflakeID；
• 2）檢查 UIN % Xiu_Partition_Num == Xiu_Partition_ID % Xiu_Partition_Num 添加是否成立【即接收人的消息是否應當由當前Xiu負責】，不成立則返回錯誤并退出；
• 3）檢查 SnowflakeID 對應的消息是否已經被存儲過，若已經存儲過則返回其對應的消息ID然后退出；
• 4）給消息分配一個 MsgID：
  每個Xiu有自己唯一的 Xiu_Partition_ID，以及一個初始值為 0 的 Partition_Msg_ID。MsgID = 1B[ Xiu_Partition_ID ] + 1B[ Message Type ] + 6B[ ++ Partition_Msg_ID ]。每次分配的時候 Partition_Msg_ID 都自增加一。
• 5）以 MsgID 為 key 把消息存入基于共享內存的 Hashtable，并存入消息的 CRC32 hash值和插入時間，把 MsgID 存入一個 LRU list 中：
  LRU List 自身并不存入共享內存中，當進程重啟時，可以根據Hashtable中的數據重構出這個List。把消息存入 Hashtable 中時，如果 Hashtable full，則依據 LRU List 對Hashtable 中的消息進行淘汰。
• 6）把MsgID返回給客戶端；
• 7）把MsgID異步通知給消息固化線程，消息固化線程根據MsgID從Hashtable中讀取消息并根據CRC32 hash值判斷消息內容是否完整，完整則把消息存入本地RocksDB中。

?

8.2.2讀取消息

讀取消息請求的參數列表為{UIN, MsgIDList}，其流程為：
?

• 1）獲取請求的 MsgIDList，判斷每個MsgID MsgID{Xiu_Partition_ID} == Xiu_Partition_ID 條件是否成立，不成立則返回錯誤并退出；
• 2）從 Hashtable 中獲取每個 MsgID 對應的消息；
• 3）如果 Hashtable 中不存在，則從 RocksDB 中讀取 MsgID 對應的消息；
• 4）讀取完畢則把所有獲取的消息返回給客戶端。

?

8.2.3主從數據同步

目前從簡，暫定Xiu的副本只有一個。

Xiu節點啟動的時候根據自身配置文件中分配的 Xiu_Partition_ID 到Registry路徑 /pubsub/xiu/partition_id 下進行注冊一個臨時有序節點，注冊成功則Registry會返回Xiu的節點 ID。

Xiu節點獲取 /pubsub/xiu/partition_id 下的所有節點的ID和地址信息，依據 節點ID最小者為leader 的原則，即可判定自己的角色。只有leader可接受讀寫數據請求。

數據同步流程如下：
?

• 1）follower定時向leader發送心跳信息，心跳信息包含本地最新消息的ID；
• 2）leader啟動一個數據同步線程處理follower的心跳信息，leader的數據同步線程從LRU list中查找 follower_latest_msg_id 之后的N條消息的ID，若獲取到則讀取消息并同步給follower，獲取不到則回復其與leader之間消息差距太大；
• 3）follower從leader獲取到最新一批消息，則存儲之；
• 4）follower若獲取leader的消息差距太大響應，則請求leader的agent把RocksDB的固化數據全量同步過來，整理完畢后再次啟動與leader之間的數據同步流程。

follower會關注Registry路徑 /pubsub/xiu/partition_id 下所有所有節點的變化情況，如果leader掛掉則及時轉換身份并接受客戶端請求。如果follower 與 leader 之間的心跳超時，則follower刪掉 leader 的 Registry 路徑節點，及時進行身份轉換處理客戶端請求。

當leader重啟或者follower轉換為leader的時候，需要把 Partition_Msg_ID 進行一個大數值增值（譬如增加1000）以防止可能的消息ID亂序情況。
?

8.2.4集群擴容

Xiu 集群擴容采用翻倍法，擴容時新 Partition 的節點啟動后工作流程如下：
?

• 1）向Registry的路徑 /pubsub/xiu/partition_id 下自己的 node 的 state 為 running，同時注冊自己的對外服務地址信息；
• 2）另外啟動一個工具，當水平擴展后所有新啟動的 Partition 內所有 Replica 的狀態都是 Running 的時候，修改 Registry 路徑 /pubsub/xiu/partition_num 的值為擴容后 Partition 的數目。按照開頭的例子，即由2升級為4。

之所以 Xiu 不用像 Broker 和 Router 那樣啟動的時候向老的 Partition 同步數據，是因為每個 Xiu 分配的 MsgID 中已經帶有 Xiu 的 PartitionID 信息，即使集群擴容這個 ID 也不變，根據這個ID也可以定位到其所在的Partition，而不是借助 hash 方法。

8.3、Pi

Pi 模塊功能名稱是 Message ID Storage，存儲每個用戶的 MsgID List。Xiu 集群也采用分 Partition 分 Replica 機制，Partition 初始數目須是2的倍數，集群擴容時采用翻倍法。
?

8.3.1存儲消息ID

MsgID 存儲的請求參數列表為{UIN，MsgID}，Pi 工作流程如下：
?

• 1）判斷條件 UIN % Pi_Partition_Num == Pi_Partition_ID % Pi_Partition_Num 是否成立，若不成立則返回error退出；
• 2）把 MsgID 插入UIN的 MsgIDList 中，保持 MsgIDList 中所有 MsgID 不重復有序遞增，把請求內容寫入本地log，給請求者返回成功響應。

Pi有專門的日志記錄線程，給每個日志操作分配一個 LogID，每個 Log 文件記錄一定量的寫操作，當文件 size 超過配置的上限后刪除之。
?

8.3.2讀取消息ID列表

讀取請求參數列表為{UIN, StartMsgID, MsgIDNum, ExpireFlag}，其意義為獲取用戶 UIN 自起始ID為 StartMsgID 起（不包括 StartMsgID ）的數目為 MsgIDNum 的消息ID列表，ExpireFlag意思是 所有小于等于 StartMsgID 的消息ID是否刪除。?

流程如下：
?

• 1）判斷條件 UIN % Pi_Partition_Num == Pi_Partition_ID % Pi_Partition_Num 是否成立，若不成立則返回error退出；
• 2）獲取 (StartID, StartMsgID + MsgIDNum] 范圍內的所有 MsgID，把結果返回給客戶端；
• 3）如果 ExpireFlag 有效，則刪除MsgIDList內所有在 [0, StartMsgID] 范圍內的MsgID，把請求內容寫入本地log。

?

8.3.3主從數據同步

同 Xiu 模塊，暫定 Pi 的同 Parition 副本只有一個。

Pi 節點啟動的時候根據自身配置文件中分配的 Pi_Partition_ID 到Registry路徑 /pubsub/pi/partition_id 下進行注冊一個臨時有序節點，注冊成功則 Registry 會返回 Pi 的節點 ID。

Pi 節點獲取 /pubsub/pi/partition_id 下的所有節點的ID和地址信息，依據 節點ID最小者為leader 的原則，即可判定自己的角色。只有 leader 可接受讀寫數據請求。

數據同步流程如下：
?

• 1）follower 定時向 leader 發送心跳信息，心跳信息包含本地最新 LogID；
• 2）leader 啟動一個數據同步線程處理 follower 的心跳信息，根據 follower 匯報的 logID 把此 LogID；
• 3）follower 從 leader 獲取到最新一批 Log，先存儲然后重放。

follower 會關注Registry路徑 /pubsub/pi/partition_id 下所有節點的變化情況，如果 leader 掛掉則及時轉換身份并接受客戶端請求。如果follower 與 leader 之間的心跳超時，則follower刪掉 leader 的 Registry 路徑節點，及時進行身份轉換處理客戶端請求。
?

8.3.4集群擴容

Pi 集群擴容采用翻倍法。則節點啟動后工作流程如下：
?

• 1）向 Registry 注冊，獲取 Registry 路徑 /pubsub/xiu/partition_num 的值 PartitionNumber；
• 2）如果發現自己 PartitionID 滿足條件 PartitionID >= PartitionNumber 時，則意味著當前 Partition 是擴容后的新集群，更新 Registry 中自己狀態為start；
• 3）讀取 Registry 路徑 /pubsub/xiu 下所有 Parition 的 leader，根據條件 自身PartitionID % PartitionNumber == PartitionID % PartitionNumber 尋找對應的老 Partition 的 leader，稱之為 parent_leader；
• 4）緩存收到 Proxy 轉發來的用戶請求；
• 5）向 parent_leader 獲取log；
• 6）向 parent_leader 同步內存數據；
• 7）重放 parent_leader 的log；
• 8）更新 Registry 中自己的狀態為 Running；
• 9）重放用戶請求；
• 10）當 Registry 路徑 /pubsub/xiu/partition_num 的值 PartitionNumber 滿足條件 PartitionID >= PartitionNumber 時，意味著擴容完成，處理用戶請求時要給用戶返回響應。

Proxy 會把讀寫請求參照條件 UIN % Pi\_Partition\_Num == Pi\_Partition\_ID % Pi\_Partition\_Num 向相關 partition 的 leader 轉發用戶請求。假設原來 PartitionNumber 值為2，擴容后值為4，則原來轉發給 partition0 的寫請求現在需同時轉發給 partition0 和 partition2，原來轉發給 partition1 的寫請求現在需同時轉發給 partition1 和 partition3。

另外啟動一個工具，當水平擴展后所有新啟動的 Partition 內所有 Replica 的狀態都是 Running 的時候，修改Registry路徑/pubsub/xiu/partition_num的值為擴容后 Partition 的數目。

8.4、數據發送流程

消息自 PiXiu 的外部客戶端（Client，服務端所有使用 PiXiu 提供的服務者統稱為客戶端）按照一定負載均衡規則發送到 Proxy，然后存入 Xiu 中，把 MsgID 存入 Pi 中。

其詳細流程如下：
?

• 1）Client 依據 snowflake 算法給消息分配 SnowflakeID，依據 ProxyID = UIN % ProxyNum 規則把消息發往某個 Proxy；
• 2）Proxy 收到消息后轉發到 Xiu；
• 3）Proxy 收到 Xiu 返回的響應后，把響應轉發給 Client；
• 4）如果 Proxy 收到 Xiu 返回的響應帶有 MsgID，則發起 Pi 寫流程，把 MsgID 同步到 Pi 中；
• 5）如果 Proxy 收到 Xiu 返回的響應帶有 MsgID，則給 Broker 發送一個 Notify，告知其某 UIN 的最新 MsgID。

?

8.5、數據轉發流程

轉發消息的主體是Broker，原來的在線消息轉發流程是它收到 Proxy 轉發來的 Message，然后根據用戶是否在線然后轉發給 Gateway。

PiXiu架構下 Broker 會收到以下類型消息：
?

• 1）用戶登錄消息；
• 2）用戶心跳消息；
• 3）用戶登出消息；
• 4）Notify 消息；
• 5）Ack 消息。

Broker流程受這五種消息驅動，下面分別詳述其收到這五種消息時的處理流程。

用戶登錄消息流程如下：
?

• 1）檢查用戶的當前狀態，若為 OffLine 則把其狀態值為在線 OnLine；
• 2）檢查用戶的待發送消息隊列是否為空，不為空則退出；
• 3）向 Pi 模塊發送獲取 N 條消息 ID 的請求 {UIN: uin, StartMsgID: 0, MsgIDNum: N, ExpireFlag: false}，設置用戶狀態為 GettingMsgIDList 并等待回應；
• 4）根據 Pi 返回的消息 ID 隊列，向 Xiu 發起獲取消息請求 {UIN: uin, MsgIDList: msg ID List}，設置用戶狀態為 GettingMsgList 并等待回應；
• 5）Xiu 返回消息列表后，設置狀態為 SendingMsg，并向 Gateway 轉發消息。

可以把用戶心跳消息當做用戶登錄消息處理。

Gateway的用戶登出消息產生有三種情況：
?

• 1）用戶主動退出；
• 2）用戶心跳超時；
• 3）給用戶轉發消息時發生網絡錯誤。

用戶登出消息處理流程如下：
?

• 1）檢查用戶狀態，如果為 OffLine，則退出；
• 2）用戶狀態不為 OffLine 且檢查用戶已經發送出去的消息列表的最后一條消息的 ID（LastMsgID），向 Pi 發送獲取 MsgID 請求{UIN: uin, StartMsgID: LastMsgID, MsgIDNum: 0, ExpireFlag: True}，待 Pi 返回響應后退出。

處理 Proxy 發來的 Notify 消息處理流程如下：
?

• 1）如果用戶狀態為 OffLine，則退出；
• 2）更新用戶的最新消息 ID（LatestMsgID），如果用戶發送消息隊列不為空則退出；
• 3）向 Pi 模塊發送獲取 N 條消息 ID 的請求 {UIN: uin, StartMsgID: 0, MsgIDNum: N, ExpireFlag: false}，設置用戶狀態為 GettingMsgIDList 并等待回應；
• 4）根據 Pi 返回的消息 ID 隊列，向 Xiu 發起獲取消息請求 {UIN: uin, MsgIDList: msg ID List}，設置用戶狀態為 GettingMsgList 并等待回應；
• 5）Xiu 返回消息列表后，設置狀態為 SendingMsg，并向 Gateway 轉發消息。

所謂 Ack 消息，就是 Broker 經 Gateway 把消息轉發給 App 后，App 給Broker的消息回復，告知Broker其最近成功收到消息的 MsgID。?

Ack 消息處理流程如下：
?

• 1）如果用戶狀態為 OffLine，則退出；
• 2）更新 LatestAckMsgID 的值；
• 3）如果用戶發送消息隊列不為空，則發送下一個消息后退出；
• 4）如果 LatestAckMsgID >= LatestMsgID，則退出；
• 5）向 Pi 模塊發送獲取 N 條消息 ID 的請求 {UIN: uin, StartMsgID: 0, MsgIDNum: N, ExpireFlag: false}，設置用戶狀態為 GettingMsgIDList 并等待回應；
• 6）根據 Pi 返回的消息 ID 隊列，向 Xiu 發起獲取消息請求 {UIN: uin, MsgIDList: msg ID List}，設置用戶狀態為 GettingMsgList 并等待回應；
• 7）Xiu 返回消息列表后，設置狀態為 SendingMsg，并向 Gateway 轉發消息。

總體上，PiXiu 轉發消息流程采用拉取（pull）轉發模型，以上面五種消息為驅動進行狀態轉換，并作出相應的動作行為。

九、本文總結

這套群聊消息系統尚有以下task list需完善：
?

• 1）消息以UDP鏈路傳遞，不可靠【2018/01/29解決之】；
• 2）目前的負載均衡算法采用了極簡的RoundRobin算法，可以根據成功率和延遲添加基于權重的負載均衡算法實現；
• 3）只考慮傳遞，沒有考慮消息的去重，可以根據消息ID實現這個功能【2018/01/29解決之】；
• 4）各個模塊之間沒有考慮心跳方案，整個系統的穩定性依賴于Registry【2018/01/17解決之】；
• 5）離線消息處理【2018/03/03解決之】；
• 6）區分消息優先級。

網易云信，你身邊的即時通訊和音視頻技術專家，了解我們，請戳網易云信官網

想要行業洞察和技術干貨，請關注網易云信博客

本文轉載自52im,作者：JackJiang

與50位技術專家面對面20年技術見證，附贈技術全景圖

總結

以上是生活随笔為你收集整理的一套高可用、易伸缩、高并发的IM群聊架构方案设计实践的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。