基於Netty實現海量接入的推送服務技術要點

IT技術精選文摘發表於2018-05-29
Netty

一．引言


1關於本次話題


最近很多從事移動網際網路和物聯網開發的同學給我發郵件或者微博私信我，諮詢推送服務相關的問題。問題五花八門，在幫助大家答疑解惑的過程中，我也對問題進行了總結，大概可以歸納為如下幾類：

  • Netty是否可以做推送伺服器？

  • 如果使用Netty開發推送服務，一個伺服器最多可以支撐多少個客戶端？

  • 使用Netty開發推送服務遇到的各種技術問題。


由於諮詢者眾多，關注點也比較集中，我希望通過本文的案例分析和對推送服務設計要點的總結，幫助大家在實際工作中少走彎路。

2關於推送服務


移動網際網路時代，推送(Push)服務成為App應用不可或缺的重要組成部分，推送服務可以提升使用者的活躍度和留存率。我們的手機每天接收到各種各樣的廣告和提示訊息等大多數都是通過推送服務實現的。

隨著物聯網的發展，大多數的智慧家居都支援移動推送服務，未來所有接入物聯網的智慧裝置都將是推送服務的客戶端，這就意味著推送服務未來會面臨海量的裝置和終端接入。

3推送服務的特點


移動推送服務的主要特點如下：

  • 使用的網路主要是運營商的無線行動網路，網路質量不穩定，例如在地鐵上訊號就很差，容易發生網路閃斷；

  • 海量的客戶端接入，而且通常使用長連線，無論是客戶端還是服務端，資源消耗都非常大；

  • 由於谷歌的推送框架無法在國內使用，Android的長連線是由每個應用各自維護的，這就意味著每檯安卓裝置上會存在多個長連線。即便沒有訊息需要推送，長連線本身的心跳訊息量也是非常巨大的，這就會導致流量和耗電量的增加；

  • 不穩定：訊息丟失、重複推送、延遲送達、過期推送時有發生；

  • 垃圾訊息滿天飛，缺乏統一的服務治理能力。


為了解決上述弊端，一些企業也給出了自己的解決方案，例如京東雲推出的推送服務，可以實現多應用單服務單連線模式，使用AlarmManager定時心跳節省電量和流量。

二．先看看某智慧家居領域的真實案例


1問題描述


智慧家居MQTT訊息服務中介軟體，保持10萬使用者線上長連線，2萬使用者併發做訊息請求。程式執行一段時間之後，發現記憶體洩露，懷疑是Netty的Bug。其它相關資訊如下：

  • MQTT訊息服務中介軟體伺服器記憶體16G，8個核心CPU；

  • Netty中boss執行緒池大小為1，worker執行緒池大小為6，其餘執行緒分配給業務使用。該分配方式後來調整為worker執行緒池大小為11，問題依舊；

  • Netty版本為4.0.8.Final。


2問題定位


首先需要dump記憶體堆疊，對疑似記憶體洩露的物件和引用關係進行分析，如下所示：

我們發現Netty的ScheduledFutureTask增加了9076%，達到110W個左右的例項，通過對業務程式碼的分析發現使用者使用IdleStateHandler用於在鏈路空閒時進行業務邏輯處理，但是空閒時間設定的比較大，為15分鐘。

Netty的IdleStateHandler會根據使用者的使用場景，啟動三類定時任務，分別是：ReaderIdleTimeoutTask、WriterIdleTimeoutTask和AllIdleTimeoutTask，它們都會被加入到NioEventLoop的Task佇列中被排程和執行。

由於超時時間過長，10W個長連結鏈路會建立10W個ScheduledFutureTask物件，每個物件還儲存有業務的成員變數，非常消耗記憶體。使用者的持久代設定的比較大，一些定時任務被老化到持久代中，沒有被JVM垃圾回收掉，記憶體一直在增長，使用者誤認為存在記憶體洩露。

事實上，我們進一步分析發現，使用者的超時時間設定的非常不合理，15分鐘的超時達不到設計目標，重新設計之後將超時時間設定為45秒，記憶體可以正常回收，問題解決。

3問題總結


如果是100個長連線，即便是長週期的定時任務，也不存在記憶體洩露問題，在新生代通過minor GC就可以實現記憶體回收。正是因為十萬級的長連線，導致小問題被放大，引出了後續的各種問題。

事實上，如果使用者確實有長週期執行的定時任務，該如何處理？對於海量長連線的推送服務，程式碼處理稍有不慎，就滿盤皆輸，下面我們針對Netty的架構特點，介紹下如何使用Netty實現百萬級客戶端的推送服務。

三．乾貨開始：Netty海量接入服務的技術要點


作為高效能的NIO框架，利用Netty開發高效的推送服務技術上是可行的，但是由於推送服務自身的複雜性，想要開發出穩定、高效能的推送服務並非易事，需要在設計階段針對推送服務的特點進行合理設計。


1最大控制程式碼數修改


百萬長連線接入，首先需要優化的就是Linux核心引數，其中Linux最大檔案控制程式碼數是最重要的調優引數之一，預設單程式開啟的最大控制程式碼數是1024，通過ulimit -a可以檢視相關引數，示例如下：

01
02
03
04
05
06
07
08
09
10
11
[root@lilinfeng ~]# ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 256324
max locked memory       (kbytes, -l) 64
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
 
......後續輸出省略


當單個推送服務接收到的連結超過上限後，就會報“too many open files”，所有新的客戶端接入將失敗。

通過vi /etc/security/limits.conf 新增如下配置引數：修改之後儲存，登出當前使用者，重新登入，通過ulimit -a 檢視修改的狀態是否生效。

1
2
*  soft　　nofile　　1000000
*  hard　　nofile　　1000000


需要指出的是，儘管我們可以將單個程式開啟的最大控制程式碼數修改的非常大，但是當控制程式碼數達到一定數量級之後，處理效率將出現明顯下降，因此，需要根據伺服器的硬體配置和處理能力進行合理設定。如果單個伺服器效能不行也可以通過叢集的方式實現。

2當心CLOSE_WAIT


從事移動推送服務開發的同學可能都有體會，移動無線網路可靠性非常差，經常存在客戶端重置連線，網路閃斷等。

在百萬長連線的推送系統中，服務端需要能夠正確處理這些網路異常，設計要點如下：

  • 客戶端的重連間隔需要合理設定，防止連線過於頻繁導致的連線失敗（例如埠還沒有被釋放）；

  • 客戶端重複登陸拒絕機制；

  • 服務端正確處理I/O異常和解碼異常等，防止控制程式碼洩露。


最後特別需要注意的一點就是close_wait 過多問題，由於網路不穩定經常會導致客戶端斷連，如果服務端沒有能夠及時關閉socket，就會導致處於close_wait狀態的鏈路過多。close_wait狀態的鏈路並不釋放控制程式碼和記憶體等資源，如果積壓過多可能會導致系統控制程式碼耗盡，發生“Too many open files”異常，新的客戶端無法接入，涉及建立或者開啟控制程式碼的操作都將失敗。

下面對close_wait狀態進行下簡單介紹，被動關閉TCP連線狀態遷移圖如下所示：

close_wait是被動關閉連線是形成的，根據TCP狀態機，伺服器端收到客戶端傳送的FIN，TCP協議棧會自動傳送ACK，連結進入close_wait狀態。但如果伺服器端不執行socket的close()操作，狀態就不能由close_wait遷移到last_ack，則系統中會存在很多close_wait狀態的連線。通常來說，一個close_wait會維持至少2個小時的時間（系統預設超時時間的是7200秒，也就是2小時）。如果服務端程式因某個原因導致系統造成一堆close_wait消耗資源，那麼通常是等不到釋放那一刻，系統就已崩潰。

導致close_wait過多的可能原因如下：

  • 程式處理Bug，導致接收到對方的fin之後沒有及時關閉socket，這可能是Netty的Bug，也可能是業務層Bug，需要具體問題具體分析；

  • 關閉socket不及時：例如I/O執行緒被意外阻塞，或者I/O執行緒執行的使用者自定義Task比例過高，導致I/O操作處理不及時，鏈路不能被及時釋放。


下面我們結合Netty的原理，對潛在的故障點進行分析。

設計要點1：不要在Netty的I/O執行緒上處理業務（心跳傳送和檢測除外）。Why? 對於Java程式，執行緒不能無限增長，這就意味著Netty的Reactor執行緒數必須收斂。Netty的預設值是CPU核數 * 2，通常情況下，I/O密集型應用建議執行緒數儘量設定大些，但這主要是針對傳統同步I/O而言，對於非阻塞I/O，執行緒數並不建議設定太大，儘管沒有最優值，但是I/O執行緒數經驗值是[CPU核數 + 1，CPU核數*2 ]之間。

假如單個伺服器支撐100萬個長連線，伺服器核心數為32，則單個I/O執行緒處理的連結數L = 100/(32 * 2) = 15625。 假如每5S有一次訊息互動（新訊息推送、心跳訊息和其它管理訊息），則平均CAPS = 15625 / 5 = 3125條/秒。這個數值相比於Netty的處理效能而言壓力並不大，但是在實際業務處理中，經常會有一些額外的複雜邏輯處理，例如效能統計、記錄介面日誌等，這些業務操作效能開銷也比較大，如果在I/O執行緒上直接做業務邏輯處理，可能會阻塞I/O執行緒，影響對其它鏈路的讀寫操作，這就會導致被動關閉的鏈路不能及時關閉，造成close_wait堆積。

設計要點2：在I/O執行緒上執行自定義Task要當心。Netty的I/O處理執行緒NioEventLoop支援兩種自定義Task的執行：

普通的Runnable: 通過呼叫NioEventLoop的execute(Runnable task)方法執行；
定時任務ScheduledFutureTask:通過呼叫NioEventLoop的schedule(Runnable command, long delay, TimeUnit unit)系列介面執行。
為什麼NioEventLoop要支援使用者自定義Runnable和ScheduledFutureTask的執行，並不是本文要討論的重點，後續會有專題文章進行介紹。本文重點對它們的影響進行分析。

在NioEventLoop中執行Runnable和ScheduledFutureTask，意味著允許使用者在NioEventLoop中執行非I/O操作類的業務邏輯，這些業務邏輯通常用訊息報文的處理和協議管理相關。它們的執行會搶佔NioEventLoop I/O讀寫的CPU時間，如果使用者自定義Task過多，或者單個Task執行週期過長，會導致I/O讀寫操作被阻塞，這樣也間接導致close_wait堆積。

所以，如果使用者在程式碼中使用到了Runnable和ScheduledFutureTask，請合理設定ioRatio的比例，通過NioEventLoop的setIoRatio(int ioRatio)方法可以設定該值，預設值為50，即I/O操作和使用者自定義任務的執行時間比為1：1。

我的建議是當服務端處理海量客戶端長連線的時候，不要在NioEventLoop中執行自定義Task，或者非心跳類的定時任務。

設計要點3：IdleStateHandler使用要當心。很多使用者會使用IdleStateHandler做心跳傳送和檢測，這種用法值得提倡。相比於自己啟定時任務傳送心跳，這種方式更高效。但是在實際開發中需要注意的是，在心跳的業務邏輯處理中，無論是正常還是異常場景，處理時延要可控，防止時延不可控導致的NioEventLoop被意外阻塞。例如，心跳超時或者發生I/O異常時，業務呼叫Email傳送介面告警，由於Email服務端處理超時，導致郵件傳送客戶端被阻塞，級聯引起IdleStateHandler的AllIdleTimeoutTask任務被阻塞，最終NioEventLoop多路複用器上其它的鏈路讀寫被阻塞。

對於ReadTimeoutHandler和WriteTimeoutHandler，約束同樣存在。

3合理的心跳週期


百萬級的推送服務，意味著會存在百萬個長連線，每個長連線都需要靠和App之間的心跳來維持鏈路。合理設定心跳週期是非常重要的工作，推送服務的心跳週期設定需要考慮移動無線網路的特點。

當一臺智慧手機連上行動網路時，其實並沒有真正連線上Internet，運營商分配給手機的IP其實是運營商的內網IP，手機終端要連線上Internet還必須通過運營商的閘道器進行IP地址的轉換，這個閘道器簡稱為NAT(NetWork Address Translation)，簡單來說就是手機終端連線Internet 其實就是移動內網IP，埠，外網IP之間相互對映。

GGSN(GateWay GPRS Support Note)模組就實現了NAT功能，由於大部分的移動無線網路運營商為了減少閘道器NAT對映表的負荷，如果一個鏈路有一段時間沒有通訊時就會刪除其對應表，造成鏈路中斷，正是這種刻意縮短空閒連線的釋放超時，原本是想節省通道資源的作用，沒想到讓網際網路的應用不得以遠高於正常頻率傳送心跳來維護推送的長連線。以中移動的2.5G網路為例，大約5分鐘左右的基帶空閒，連線就會被釋放。

由於移動無線網路的特點，推送服務的心跳週期並不能設定的太長，否則長連線會被釋放，造成頻繁的客戶端重連，但是也不能設定太短，否則在當前缺乏統一心跳框架的機制下很容易導致信令風暴（例如微信心跳信令風暴問題）。具體的心跳週期並沒有統一的標準，180S也許是個不錯的選擇，微信為300S。

在Netty中，可以通過在ChannelPipeline中增加IdleStateHandler的方式實現心跳檢測，在建構函式中指定鏈路空閒時間，然後實現空閒回撥介面，實現心跳的傳送和檢測，程式碼如下：

01
02
03
04
05
06
07
08
09
10
11
12
13
public void initChannel({@link Channel} channel) {
 channel.pipeline().addLast("idleStateHandler", new {@link   IdleStateHandler}(0, 0, 180));
 channel.pipeline().addLast("myHandler", new MyHandler());
}
攔截鏈路空閒事件並處理心跳：
 public class MyHandler extends {@link ChannelHandlerAdapter} {
     {@code @Override}
      public void userEventTriggered({@link ChannelHandlerContext} ctx, {@link Object} evt) throws {@link Exception} {
          if (evt instanceof {@link IdleStateEvent}} {
              //心跳處理
          }
      }
  }


4合理設定接收和傳送緩衝區容量


對於長連結，每個鏈路都需要維護自己的訊息接收和傳送緩衝區，JDK原生的NIO類庫使用的是java.nio.ByteBuffer,它實際是一個長度固定的Byte陣列，我們都知道陣列無法動態擴容，ByteBuffer也有這個限制，相關程式碼如下：

1
2
3
4
5
6
7
public abstract class ByteBuffer
    extends Buffer
    implements Comparable
{
    final byte[] hb; // Non-null only for heap buffers
    final int offset;
    boolean isReadOnly;


容量無法動態擴充套件會給使用者帶來一些麻煩，例如由於無法預測每條訊息報文的長度，可能需要預分配一個比較大的ByteBuffer，這通常也沒有問題。但是在海量推送服務系統中，這會給服務端帶來沉重的記憶體負擔。假設單條推送訊息最大上限為10K，訊息平均大小為5K，為了滿足10K訊息的處理，ByteBuffer的容量被設定為10K，這樣每條鏈路實際上多消耗了5K記憶體，如果長連結鏈路數為100萬，每個鏈路都獨立持有ByteBuffer接收緩衝區，則額外損耗的總記憶體 Total(M) = 1000000 * 5K = 4882M。記憶體消耗過大，不僅僅增加了硬體成本，而且大記憶體容易導致長時間的Full GC，對系統穩定性會造成比較大的衝擊。

實際上，最靈活的處理方式就是能夠動態調整記憶體，即接收緩衝區可以根據以往接收的訊息進行計算，動態調整記憶體，利用CPU資源來換記憶體資源，具體的策略如下：

  • ByteBuffer支援容量的擴充套件和收縮，可以按需靈活調整，以節約記憶體；

  • 接收訊息的時候，可以按照指定的演算法對之前接收的訊息大小進行分析，並預測未來的訊息大小，按照預測值靈活調整緩衝區容量，以做到最小的資源損耗滿足程式正常功能。


幸運的是，Netty提供的ByteBuf支援容量動態調整，對於接收緩衝區的記憶體分配器，Netty提供了兩種：

  • FixedRecvByteBufAllocator：固定長度的接收緩衝區分配器，由它分配的ByteBuf長度都是固定大小的，並不會根據實際資料包的大小動態收縮。但是，如果容量不足，支援動態擴充套件。動態擴充套件是Netty ByteBuf的一項基本功能，與ByteBuf分配器的實現沒有關係；

  • AdaptiveRecvByteBufAllocator：容量動態調整的接收緩衝區分配器，它會根據之前Channel接收到的資料包大小進行計算，如果連續填充滿接收緩衝區的可寫空間，則動態擴充套件容量。如果連續2次接收到的資料包都小於指定值，則收縮當前的容量，以節約記憶體。


相對於FixedRecvByteBufAllocator，使用AdaptiveRecvByteBufAllocator更為合理，可以在建立客戶端或者服務端的時候指定RecvByteBufAllocator，程式碼如下：

1
2
3
4
5
Bootstrap b = new Bootstrap();
            b.group(group)
             .channel(NioSocketChannel.class)
             .option(ChannelOption.TCP_NODELAY, true)
             .option(ChannelOption.RCVBUF_ALLOCATOR, AdaptiveRecvByteBufAllocator.DEFAULT)

如果預設沒有設定，則使用AdaptiveRecvByteBufAllocator。

另外值得注意的是，無論是接收緩衝區還是傳送緩衝區，緩衝區的大小建議設定為訊息的平均大小，不要設定成最大訊息的上限，這會導致額外的記憶體浪費。通過如下方式可以設定接收緩衝區的初始大小：

1
2
3
4
5
6
7
8
/**
  * Creates a new predictor with the specified parameters.
  *
  * @param minimum the inclusive lower bound of the expected buffer size
  * @param initial the initial buffer size when no feed back was received
  * @param maximum the inclusive upper bound of the expected buffer size
  */
public AdaptiveRecvByteBufAllocator(int minimum, int initial, int maximum)


對於訊息傳送，通常需要使用者自己構造ByteBuf並編碼，例如通過如下工具類建立訊息傳送緩衝區：

 

5記憶體池


推送伺服器承載了海量的長連結，每個長連結實際就是一個會話。如果每個會話都持有心跳資料、接收緩衝區、指令集等資料結構，而且這些例項隨著訊息的處理朝生夕滅，這就會給伺服器帶來沉重的GC壓力，同時消耗大量的記憶體。

最有效的解決策略就是使用記憶體池，每個NioEventLoop執行緒處理N個鏈路，線上程內部，鏈路的處理時序列的。假如A鏈路首先被處理，它會建立接收緩衝區等物件，待解碼完成之後，構造的POJO物件被封裝成Task後投遞到後臺的執行緒池中執行，然後接收緩衝區會被釋放，每條訊息的接收和處理都會重複接收緩衝區的建立和釋放。如果使用記憶體池，則當A鏈路接收到新的資料包之後，從NioEventLoop的記憶體池中申請空閒的ByteBuf，解碼完成之後，呼叫release將ByteBuf釋放到記憶體池中，供後續B鏈路繼續使用。

使用記憶體池優化之後，單個NioEventLoop的ByteBuf申請和GC次數從原來的N = 1000000/64 = 15625 次減少為最少0次（假設每次申請都有可用的記憶體）。

下面我們以Twitter使用Netty4的PooledByteBufAllocator進行GC優化作為案例（點選檢視該文章），對記憶體池的效果進行評估，結果如下：

垃圾生成速度是原來的1/5，而垃圾清理速度快了5倍。使用新的記憶體池機制，幾乎可以把網路頻寬壓滿。


Netty 4之前的版本問題如下：每當收到新資訊或者使用者傳送資訊到遠端端，Netty 3均會建立一個新的堆緩衝區。這意味著，對應每一個新的緩衝區，都會有一個new byte[capacity]。這些緩衝區會導致GC壓力，並消耗記憶體頻寬。為了安全起見，新的位元組陣列分配時會用零填充，這會消耗記憶體頻寬。然而，用零填充的陣列很可能會再次用實際的資料填充，這又會消耗同樣的記憶體頻寬。如果Java虛擬機器（JVM）提供了建立新位元組陣列而又無需用零填充的方式，那麼我們本來就可以將記憶體頻寬消耗減少50%，但是目前沒有那樣一種方式。

在Netty 4中實現了一個新的ByteBuf記憶體池，它是一個純Java版本的 jemalloc （Facebook也在用）。現在，Netty不會再因為用零填充緩衝區而浪費記憶體頻寬了。不過，由於它不依賴於GC，開發人員需要小心記憶體洩漏。如果忘記在處理程式中釋放緩衝區，那麼記憶體使用率會無限地增長。

Netty預設不使用記憶體池，需要在建立客戶端或者服務端的時候進行指定，程式碼如下：

1
2
3
4
5
Bootstrap b = new Bootstrap();
            b.group(group)
             .channel(NioSocketChannel.class)
             .option(ChannelOption.TCP_NODELAY, true)
             .option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT)


使用記憶體池之後，記憶體的申請和釋放必須成對出現，即retain()和release()要成對出現，否則會導致記憶體洩露。

值得注意的是，如果使用記憶體池，完成ByteBuf的解碼工作之後必須顯式的呼叫ReferenceCountUtil.release(msg)對接收緩衝區ByteBuf進行記憶體釋放，否則它會被認為仍然在使用中，這樣會導致記憶體洩露。

6當心“日誌隱形殺手”


通常情況下，大家都知道不能在Netty的I/O執行緒上做執行時間不可控的操作，例如訪問資料庫、傳送Email等。但是有個常用但是非常危險的操作卻容易被忽略，那便是記錄日誌。

通常，在生產環境中，需要實時列印介面日誌，其它日誌處於ERROR級別，當推送服務發生I/O異常之後，會記錄異常日誌。如果當前磁碟的WIO比較高，可能會發生寫日誌檔案操作被同步阻塞，阻塞時間無法預測。這就會導致Netty的NioEventLoop執行緒被阻塞，Socket鏈路無法被及時關閉、其它的鏈路也無法進行讀寫操作等。

以最常用的log4j為例，儘管它支援非同步寫日誌（AsyncAppender），但是當日志佇列滿之後，它會同步阻塞業務執行緒，直到日誌佇列有空閒位置可用，相關程式碼如下：

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
16
17
18
19
20
21
synchronized (this.buffer) {
      while (true) {
        int previousSize = this.buffer.size();
        if (previousSize < this.bufferSize) {
          this.buffer.add(event);
          if (previousSize != 0) break;
          this.buffer.notifyAll(); break;
        }
        boolean discard = true;
        if ((this.blocking) && (!Thread.interrupted()) && (Thread.currentThread() != this.dispatcher)) //判斷是業務執行緒
        {
          try
          {
            this.buffer.wait();//阻塞業務執行緒
            discard = false;
          }
          catch (InterruptedException e)
          {
            Thread.currentThread().interrupt();
          }
        }


類似這類BUG具有極強的隱蔽性，往往WIO高的時間持續非常短，或者是偶現的，在測試環境中很難模擬此類故障，問題定位難度非常大。這就要求讀者在平時寫程式碼的時候一定要當心，注意那些隱性地雷。

7TCP引數優化


常用的TCP引數，例如TCP層面的接收和傳送緩衝區大小設定，在Netty中分別對應ChannelOption的SO_SNDBUF和SO_RCVBUF，需要根據推送訊息的大小，合理設定，對於海量長連線，通常32K是個不錯的選擇。

另外一個比較常用的優化手段就是軟中斷，如圖所示：如果所有的軟中斷都執行在CPU0相應網路卡的硬體中斷上，那麼始終都是cpu0在處理軟中斷，而此時其它CPU資源就被浪費了，因為無法並行的執行多個軟中斷。

大於等於2.6.35版本的Linux kernel核心，開啟RPS，網路通訊效能提升20%之上。RPS的基本原理：根據資料包的源地址，目的地址以及目的和源埠，計算出一個hash值，然後根據這個hash值來選擇軟中斷執行的cpu。從上層來看，也就是說將每個連線和cpu繫結，並通過這個hash值，來均衡軟中斷執行在多個cpu上，從而提升通訊效能。

8JVM引數


最重要的引數調整有兩個：

  • -Xmx:JVM最大記憶體需要根據記憶體模型進行計算並得出相對合理的值；

  • GC相關的引數: 例如新生代和老生代、永久代的比例，GC的策略，新生代各區的比例等，需要根據具體的場景進行設定和測試，並不斷的優化，儘量將Full GC的頻率降到最低。

公眾號推薦:

相關文章