1 模擬單機連線瓶頸
我們知道，通常啟動一個服務端會繫結一個埠，例如8000埠，當然客戶端連線埠是有限制的，除去最大埠65535和預設的1024埠及以下的埠，就只剩下1 024~65 535個，再扣除一些常用埠，實際可用埠只有6萬個左右。那麼，我們如何實現單機百萬連線呢？
假設在服務端啟動[8 000,8 100）這100個埠，100×6萬就可以實現600萬左右的連線，這是TCP的一個基礎知識，雖然對於客戶端來說是同一個埠號，但是對於服務端來說是不同的埠號，由於TCP是一個私源組概念，也就是說它是由源IP地址、源埠號、目的IP地址和目的埠號確定的，當源IP地址和源埠號是一樣的，但是目的埠號不一樣，那麼最終系統底層會把它當作兩條TCP連線來處理，所以這裡取巧給服務端開啟了100個埠號，這就是單機百萬連線的準備工作，如下圖所示。
單機1024及以下的埠只能給ROOT保留使用，客戶端埠範圍為1 025~65 535，接下來用程式碼實現單機百萬連線的模擬場景。先看服務端類，迴圈開啟[8 000~8 100）這100個監聽埠，等待客戶端連線。下面已Netty為例編寫程式碼如下。
package com.tom.netty.connection;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
/**
* @author Tom
*/
public final class Server {
public static final int BEGIN_PORT = 8000;
public static final int N_PORT = 8100;
public static void main(String[] args) {
new Server().start(Server.BEGIN_PORT, Server.N_PORT);
}
public void start(int beginPort, int nPort) {
System.out.println("服務端啟動中...");
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup, workerGroup);
bootstrap.channel(NioServerSocketChannel.class);
bootstrap.childOption(ChannelOption.SO_REUSEADDR, true);
bootstrap.childHandler(new ConnectionCountHandler());
for (int i = 0; i <= (nPort - beginPort); i++) {
final int port = beginPort + i;
bootstrap.bind(port).addListener(new ChannelFutureListener() {
public void operationComplete(ChannelFuture channelFuture) throws Exception {
System.out.println("成功繫結監聽埠: " + port);
}
});
}
System.out.println("服務端已啟動!");
}
}
然後看ConnectionCountHandler類的實現邏輯，主要用來統計單位時間內的請求數，每接入一個連線則自增一個數字，每2s統計一次，程式碼如下。
package com.tom.netty.connection;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
/**
* Created by Tom.
*/
@ChannelHandler.Sharable
public class ConnectionCountHandler extends ChannelInboundHandlerAdapter {
private AtomicInteger nConnection = new AtomicInteger();
public ConnectionCountHandler() {
Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(new Runnable() {
public void run() {
System.out.println("當前客戶端連線數: " + nConnection.get());
}
},0, 2, TimeUnit.SECONDS);
}
@Override
public void channelActive(ChannelHandlerContext ctx) {
nConnection.incrementAndGet();
}
@Override
public void channelInactive(ChannelHandlerContext ctx) {
nConnection.decrementAndGet();
}
}
再看客戶端類程式碼，主要功能是迴圈依次往服務端開啟的100個埠發起請求，直到服務端無響應、執行緒掛起為止，程式碼如下。
package com.tom.netty.connection;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
/**
* Created by Tom.
*/
public class Client {
private static final String SERVER_HOST = "127.0.0.1";
public static void main(String[] args) {
new Client().start(Server.BEGIN_PORT, Server.N_PORT);
}
public void start(final int beginPort, int nPort) {
System.out.println("客戶端已啟動...");
EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
final Bootstrap bootstrap = new Bootstrap();
bootstrap.group(eventLoopGroup);
bootstrap.channel(NioSocketChannel.class);
bootstrap.option(ChannelOption.SO_REUSEADDR, true);
bootstrap.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) {
}
});
int index = 0;
int port;
while (!Thread.interrupted()) {
port = beginPort + index;
try {
ChannelFuture channelFuture = bootstrap.connect(SERVER_HOST, port);
channelFuture.addListener(new ChannelFutureListener() {
public void operationComplete(ChannelFuture future) throws Exception {
if (!future.isSuccess()) {
System.out.println("連線失敗，程式關閉!");
System.exit(0);
}
}
});
channelFuture.get();
} catch (Exception e) {
}
if (port == nPort) { index = 0; }else { index ++; }
}
}
}
最後，將服務端程式打包釋出到Linux伺服器上，同樣將客戶端程式打包釋出到另一臺Linux伺服器上。接下來分別啟動服務端和客戶端程式。執行一段時間之後，會發現服務端監聽的連線數定格在一個值不再變化，如下所示。
當前客戶端連線數: 870
當前客戶端連線數: 870
當前客戶端連線數: 870
當前客戶端連線數: 870
當前客戶端連線數: 870
當前客戶端連線數: 870
當前客戶端連線數: 870
當前客戶端連線數: 870
當前客戶端連線數: 870
...
並且丟擲如下異常。
Exception in thread "nioEventLoopGroup-2-1" java.lang.InternalError: java.io.FileNotFoundException: /usr/java/jdk1.8.0_121/jre/lib/ext/cldrdata.jar (Too many open files)
at sun.misc.URLClassPath$JarLoader.getResource(URLClassPath.java:1040)
at sun.misc.URLClassPath.getResource(URLClassPath.java:239)
at java.net.URLClassLoader$1.run(URLClassLoader.java:365)
at java.net.URLClassLoader$1.run(URLClassLoader.java:362)
at java.security.AccessController.doPrivileged(Native Method)
at java.net.URLClassLoader.findClass(URLClassLoader.java:361)
at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
at java.lang.ClassLoader.loadClass(ClassLoader.java:411)
at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:331)
at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
at java.util.ResourceBundle$RBClassLoader.loadClass(ResourceBundle.java:503)
at java.util.ResourceBundle$Control.newBundle(ResourceBundle.java:2640)
at java.util.ResourceBundle.loadBundle(ResourceBundle.java:1501)
at java.util.ResourceBundle.findBundle(ResourceBundle.java:1465)
at java.util.ResourceBundle.findBundle(ResourceBundle.java:1419)
at java.util.ResourceBundle.getBundleImpl(ResourceBundle.java:1361)
at java.util.ResourceBundle.getBundle(ResourceBundle.java:845)
at java.util.logging.Level.computeLocalizedLevelName(Level.java:265)
at java.util.logging.Level.getLocalizedLevelName(Level.java:324)
at java.util.logging.SimpleFormatter.format(SimpleFormatter.java:165)
at java.util.logging.StreamHandler.publish(StreamHandler.java:211)
at java.util.logging.ConsoleHandler.publish(ConsoleHandler.java:116)
at java.util.logging.Logger.log(Logger.java:738)
at io.netty.util.internal.logging.JdkLogger.log(JdkLogger.java:606)
at io.netty.util.internal.logging.JdkLogger.warn(JdkLogger.java:482)
at io.netty.util.concurrent.SingleThreadEventExecutor$5.run (SingleThreadEventExecutor.java:876)
at io.netty.util.concurrent.DefaultThreadFactory$DefaultRunnableDecorator.run (DefaultThreadFactory.java:144)
at java.lang.Thread.run(Thread.java:745)
這個時候，我們就應該要知道，這已經是伺服器所能接受客戶端連線數量的瓶頸值，也就是服務端最大支援870個連線。接下來要做的事情是想辦法突破這個瓶頸，讓單臺伺服器也能支援100萬連線，這是一件多麼激動人心的事情。
2 單機百萬連線調優解決思路
2.1 突破區域性檔案控制程式碼限制
首先在服務端輸入命令，看一下單個程式所能支援的最大控制程式碼數。
ulimit -n
輸入命令後，會出現1 024的數字，表示Linux系統中一個程式能夠開啟的最大檔案數，由於開啟一個TCP連線就會在Linux系統中對應建立一個檔案，所以就是受這個檔案的最大檔案數限制。那為什麼前面演示的服務端連線數最終定格在870，比1 024小呢？其實是因為除了連線數，還有JVM開啟的檔案Class類也算作程式內開啟的檔案，所以，1 024減去JVM開啟的檔案數剩下的就是TCP所能支援的連線數。
接下來想辦法突破這個限制，首先在伺服器命令列輸入以下命令，開啟/etc/security/limits.conf檔案。
sudo vi /etc/security/limits.conf
然後在這個檔案末尾加上下面兩行程式碼。
* hard nofile 1000000
* soft nofile 1000000
前面的*表示當前使用者，hard和soft分別表示限制和警告限制，nofile表示最大的檔案數標識，後面的數字1 000 000表示任何使用者都能開啟100萬個檔案，這也是作業系統所能支援的最大值，如下圖所示。
接下來，輸入以下命令。
ulimit -n
這時候，我們發現還是1 024，沒變，重啟伺服器。將服務端程式和客戶端程式分別重新執行，這時候只需靜靜地觀察連線數的變化，最終連線數停留在137 920，同時丟擲了異常，如下所示。
當前客戶端連線數: 137920
當前客戶端連線數: 137920
當前客戶端連線數: 137920
當前客戶端連線數: 137920
當前客戶端連線數: 137920
Exception in thread "nioEventLoopGroup-2-1" java.lang.InternalError: java.io.FileNotFoundException: /usr/java/jdk1.8.0_121/jre/lib/ext/cldrdata.jar (Too many open files)
...
這又是為什麼呢？肯定還有地方限制了連線數，想要突破這個限制，就需要突破全域性檔案控制程式碼數的限制。
2.2 突破全域性檔案控制程式碼限制
首先在Linux命令列輸入以下命令，可以檢視Linux系統所有使用者程式所能開啟的檔案數。
cat /proc/sys/fs/file-max
通過上面這個命令可以看到全域性的限制，發現得到的結果是10 000。可想而知，區域性檔案控制程式碼數不能大於全域性的檔案控制程式碼數。所以，必須將全域性的檔案控制程式碼數限制調大，突破這個限制。首先切換為ROOT使用者，不然沒有許可權。
sudo -s
echo 2000> /proc/sys/fs/file-max
exit
我們改成20 000來測試一下，繼續試驗。分別啟動服務端程式和客戶端程式，發現連線數已經超出了20 000的限制。
前面使用echo來配置/proc/sys/fs/file-max的話，重啟伺服器就會失效，還會變回原來的10 000，因此，直接用vi命令修改，輸入以下命令列。
sodu vi /etc/sysctl.conf
在/etc/sysctl.conf檔案末尾加上下面的內容。
fs.file-max=1000000
結果如下圖所示。
接下來重啟 Linux伺服器，再啟動服務端程式和客戶端程式。
當前客戶端連線數: 9812451
當前客戶端連線數: 9812462
當前客戶端連線數: 9812489
當前客戶端連線數: 9812501
當前客戶端連線數: 9812503
...
最終連線數定格在 98萬左右。我們發現主要受限於本機本身的效能。用htop命令檢視一下，發現CPU都接近100%，如下圖所示。
以上是作業系統層面的調優和效能提升，下面主要介紹基於Netty應用層面的調優。
3 Netty應用級別的效能調優
3.1 Netty應用級別的效能瓶頸復現
首先來看一下應用場景，下面是一段標準的服務端應用程式程式碼。
package com.tom.netty.thread;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.FixedLengthFrameDecoder;
/**
* Created by Tom.
*/
public class Server {
private static final int port = 8000;
public static void main(String[] args) {
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
final EventLoopGroup businessGroup = new NioEventLoopGroup(1000);
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childOption(ChannelOption.SO_REUSEADDR, true);
bootstrap.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) {
//自定義長度的解碼，每次傳送一個long型別的長度資料
//每次傳遞一個系統的時間戳
ch.pipeline().addLast(new FixedLengthFrameDecoder(Long.BYTES));
ch.pipeline().addLast(businessGroup, ServerHandler.INSTANCE);
}
});
ChannelFuture channelFuture = bootstrap.bind(port).addListener(new ChannelFutureListener() {
public void operationComplete(ChannelFuture channelFuture) throws Exception {
System.out.println("服務端啟動成功，繫結埠為: " + port);
}
});
}
}
我們重點關注服務端的邏輯處理ServerHandler類。
package com.tom.netty.thread;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import java.util.concurrent.ThreadLocalRandom;
/**
* Created by Tom.
*/
@ChannelHandler.Sharable
public class ServerHandler extends SimpleChannelInboundHandler<ByteBuf> {
public static final ChannelHandler INSTANCE = new ServerHandler();
//channelread0是主執行緒
@Override
protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) {
ByteBuf data = Unpooled.directBuffer();
//從客戶端讀一個時間戳
data.writeBytes(msg);
//模擬一次業務處理，有可能是資料庫操作，也有可能是邏輯處理
Object result = getResult(data);
//重新寫回給客戶端
ctx.channel().writeAndFlush(result);
}
//模擬去資料庫獲取一個結果
protected Object getResult(ByteBuf data) {
int level = ThreadLocalRandom.current().nextInt(1, 1000);
//計算出每次響應需要的時間，用來作為QPS的參考資料
//90.0% == 1ms 1000 100 > 1ms
int time;
if (level <= 900) {
time = 1;
//95.0% == 10ms 1000 50 > 10ms
} else if (level <= 950) {
time = 10;
//99.0% == 100ms 1000 10 > 100ms
} else if (level <= 990) {
time = 100;
//99.9% == 1000ms 1000 1 > 1000ms
} else {
time = 1000;
}
try {
Thread.sleep(time);
} catch (InterruptedException e) {
}
return data;
}
}
上面程式碼中有一個getResult()方法。可以把getResult()方法看作是在資料庫中查詢資料的一個方法，把每次查詢的結果返回給客戶端。實際上，為了模擬查詢資料效能，getResult()傳入的引數是由客戶端傳過來的時間戳，最終返回的還是客戶端傳過來的值。只不過返回之前做了一次隨機的執行緒休眠處理，以模擬真實的業務處理效能。如下表所示是模擬場景的效能引數。
| 資料處理的業務介面占比 | 處理所耗的時間 |
|---|---|
| 90% | 1ms |
| 95% | 10ms |
| 99% | 100ms |
| 99.9% | 1000ms |
下面來看客戶端，也是一段標準的程式碼。
package com.tom.netty.thread;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.FixedLengthFrameDecoder;
/**
* Created by Tom.
*/
public class Client {
private static final String SERVER_HOST = "127.0.0.1";
public static void main(String[] args) throws Exception {
new Client().start(8000);
}
public void start(int port) throws Exception {
EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
final Bootstrap bootstrap = new Bootstrap();
bootstrap.group(eventLoopGroup)
.channel(NioSocketChannel.class)
.option(ChannelOption.SO_REUSEADDR, true)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) {
ch.pipeline().addLast(new FixedLengthFrameDecoder(Long.BYTES));
ch.pipeline().addLast(ClientHandler.INSTANCE);
}
});
//客戶端每秒鐘向服務端發起1 000次請求
for (int i = 0; i < 1000; i++) {
bootstrap.connect(SERVER_HOST, port).get();
}
}
}
從上面程式碼中看到，客戶端會向服務端發起1 000次請求。重點來看客戶端邏輯處理ClientHandler類。
package com.tom.netty.thread;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
/**
* Created by Tom.
*/
@ChannelHandler.Sharable
public class ClientHandler extends SimpleChannelInboundHandler<ByteBuf> {
public static final ChannelHandler INSTANCE = new ClientHandler();
private static AtomicLong beginTime = new AtomicLong(0);
//總響應時間
private static AtomicLong totalResponseTime = new AtomicLong(0);
//總請求數
private static AtomicInteger totalRequest = new AtomicInteger(0);
public static final Thread THREAD = new Thread(){
@Override
public void run() {
try {
while (true) {
long duration = System.currentTimeMillis() - beginTime.get();
if (duration != 0) {
System.out.println("QPS: " + 1000 * totalRequest.get() / duration + ", " + "平均響應時間: " + ((float) totalResponseTime.get()) / totalRequest.get() + "ms.");
Thread.sleep(2000);
}
}
} catch (InterruptedException ignored) {
}
}
};
@Override
public void channelActive(final ChannelHandlerContext ctx) {
ctx.executor().scheduleAtFixedRate(new Runnable() {
public void run() {
ByteBuf byteBuf = ctx.alloc().ioBuffer();
//將當前系統時間傳送到服務端
byteBuf.writeLong(System.currentTimeMillis());
ctx.channel().writeAndFlush(byteBuf);
}
}, 0, 1, TimeUnit.SECONDS);
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) {
//獲取一個響應時間差，本次請求的響應時間
totalResponseTime.addAndGet(System.currentTimeMillis() - msg.readLong());
//每次自增
totalRequest.incrementAndGet();
if (beginTime.compareAndSet(0, System.currentTimeMillis())) {
THREAD.start();
}
}
}
上面程式碼主要模擬了Netty真實業務環境下的處理耗時情況，QPS大概在1 000次，每2s統計一次。接下來，啟動服務端和客戶端檢視控制檯日誌。首先執行服務端，看到控制檯日誌如下圖所示。
然後執行客戶端，看到控制檯日誌如下圖所示，一段時間之後，發現QPS保持在1 000次以內，平均響應時間越來越長。
回到服務端ServerHander的getResul()方法，在getResult()方法中有執行緒休眠導致阻塞，不難發現，它最終會阻塞主執行緒，導致所有的請求擠壓在一個執行緒中。如果把下面的程式碼放入執行緒池中，效果將完全不同。
Object result =getResult(data);
ctx.channel().wrteAndFlush(result);
把這兩行程式碼放到業務執行緒池裡，不斷在後臺執行，執行完成後即時返回結果。
3.2 Netty應用級別的效能調優方案
下面來改造一下程式碼，在服務端的程式碼中新建一個ServerThreadPoolHander類。
package com.tom.netty.thread;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* Created by Tom.
*/
@ChannelHandler.Sharable
public class ServerThreadPoolHandler extends ServerHandler {
public static final ChannelHandler INSTANCE = new ServerThreadPoolHandler();
private static ExecutorService threadPool = Executors.newFixedThreadPool(1000);
@Override
protected void channelRead0(final ChannelHandlerContext ctx, ByteBuf msg) {
final ByteBuf data = Unpooled.directBuffer();
data.writeBytes(msg);
threadPool.submit(new Runnable() {
public void run() {
Object result = getResult(data);
ctx.channel().writeAndFlush(result);
}
});
}
}
然後在服務端的Handler處理註冊為ServerThreadPoolHander，刪除原來的ServerHandler，程式碼如下。
ch.pipeline().addLast(ServerThreadPoolHandler.INSTANCE);
隨後，啟動服務端和客戶端程式，檢視控制檯日誌，如下圖所示。
最終耗時穩定在15ms左右，QPS也超過了1 000次。實際上這個結果還不是最優的狀態，繼續調整。將ServerThreadPoolHander的執行緒個數調整到20，程式碼如下。
public static final ChannelHandler INSTANCE = new ServerThreadPoolHandler();
private static ExecutorService threadPool = Executors.newFixedThreadPool(20);
然後啟動程式，發現平均響應時間相差也不是太多，如下圖所示。
由此得出的結論是：具體的執行緒數需要在真實的環境下不斷地調整、測試，才能確定最合適的數值。本章旨在告訴大家優化的方法，而不是結果。
本文為“Tom彈架構”原創，轉載請註明出處。技術在於分享，我分享我快樂！
如果本文對您有幫助，歡迎關注和點贊；如果您有任何建議也可留言評論或私信，您的支援是我堅持創作的動力。關注微信公眾號『 Tom彈架構 』可獲取更多技術乾貨！