掃二維碼與項目經(jīng)理溝通
我們在微信上24小時期待你的聲音
解答本文疑問/技術(shù)咨詢/運營咨詢/技術(shù)建議/互聯(lián)網(wǎng)交流
前言
成都創(chuàng)新互聯(lián)于2013年開始，是專業(yè)互聯(lián)網(wǎng)技術(shù)服務(wù)公司，擁有項目成都網(wǎng)站建設(shè)、網(wǎng)站設(shè)計網(wǎng)站策劃，項目實施與項目整合能力。我們以讓每一個夢想脫穎而出為使命，1280元蘭山做網(wǎng)站,已為上家服務(wù),為蘭山各地企業(yè)和個人服務(wù),聯(lián)系電話:028-86922220
在學(xué)習(xí)Netty 之前我們最好先掌握 BIO、NIO、AIO 基礎(chǔ)知識，前面我們已經(jīng)花了三篇文章去講這些知識。我們開始來學(xué)習(xí) Netty 的具體知識了，本文就Netty線程模型展開分析。
基本概念
IO 模型
NIO 和 AIO 不同之處在于應(yīng)用是否進(jìn)行真正的讀寫操作。
reactor 和 proactor 模型
Netty認(rèn)識
Netty是Java領(lǐng)域有名的開源網(wǎng)絡(luò)庫，特點是高性能和高擴(kuò)展性，因此很多流行的框架都是基于它來構(gòu)建的，比如我們熟知的Dubbo、Rocketmq、Hadoop等。
通過前面 NIO 的學(xué)習(xí)可以看到，NIO 的類庫和API 繁雜，例如 Selector、 ServerSocketChannel、 SocketChannel、 ByteBuffer等這些對于從事應(yīng)用層的程序員來說，使用起來開發(fā)工作量和難度都非常大。另外客戶端面臨斷連重連、 網(wǎng)絡(luò)閃斷、心跳處理、半包讀寫、 網(wǎng)絡(luò)擁塞 和異常流的處理等等。
Netty 對 JDK 自帶的 NIO 的 API 進(jìn)行了良好的封裝，解決了上述問題。且Netty擁有高性能、 吞吐量更高，延遲更低，減少資源消耗，最小化不必要的內(nèi)存復(fù)制等優(yōu)點。
Netty 現(xiàn)在都在用的是4.x，5.x版本已經(jīng)廢棄，Netty 4.x 需要JDK 6以上版本支持。
在了解Netty使用場景后，本節(jié)將從IO模型的演進(jìn)角度來分析Netty線程模型，通過并發(fā)編程之父Doug Lea所寫《Scalable IO in Java》中涉及的一些IO處理模式，一步一步深入理解Netty線程模型的“進(jìn)化歷史”。
《Scalable IO in Java》：
http://gee.cs.oswego.edu/dl/cpjslides/nio.pdf
Netty使用場景
Netty相關(guān)開源項目：
https://netty.io/wiki/related-projects.html
IO處理模式演進(jìn)
基本上所有的網(wǎng)絡(luò)處理程序都遵循以下基本的處理（handler）流程:
傳統(tǒng)網(wǎng)絡(luò)服務(wù)器會為每一個連接的處理開啟一個新的線程，即我們前面所說的BIO模型（多線程模式），我們可以看下大致的示意圖：
上圖為 BIO版本
BIO模型對于每一個請求都分發(fā)給一個線程（可以理解為一個handler），每個handler中都獨自處理上面1-5流程。這種模型的適用場景和瓶頸可以查看《BIO 、NIO 、AIO 總結(jié)》。
改進(jìn)：采用基于事件驅(qū)動的設(shè)計，當(dāng)有事件觸發(fā)時，才會調(diào)用處理器進(jìn)行數(shù)據(jù)處理（非阻塞）。這就是對應(yīng)的NIO線程模型。
上圖為單線程版事件驅(qū)動模型，可以理解為NIO單線程版本
上面用到了 Reactor 模式。關(guān)于 Reactor 模式的兩個概念：
注意：Reactor 為單個線程，如上圖所示：不僅需要處理客戶端的 accept 連接請求，同時也要負(fù)責(zé)分發(fā)（dispatch）讀寫請求到處理器中。由于只有單個線程處理各種請求，所以要求處理器中的業(yè)務(wù)需要能夠快速處理完。
改進(jìn)：現(xiàn)在的服務(wù)器基本上是多核 CPU，那么在多處理器場景下，為實現(xiàn)服務(wù)的高性能我們可以有目的的采用多線程模式處理業(yè)務(wù)。
上圖為多線程版本事件驅(qū)動模型，可以理解為NIO多線程版本
通過與NIO單線程模型相比，增加了worker線程池，專門用于處理非IO操作（decode、compute、encode），大大提高了工作效率。
這種模型下，客戶端發(fā)送過來的連接和注冊還是由主線程 Reactor 統(tǒng)一去處理，只不過客戶端連接成功后的后續(xù)事件分發(fā)給 worker 線程池去處理。
但是，當(dāng)客戶端短時間內(nèi)幾十萬或者上百萬條連接請求的時候（雙十一、春運搶票），單個 Rector 不僅要處理注冊事件，也要同時分發(fā)任務(wù)到 worker 線程池，由于分發(fā)也是比較耗時的操作，有可能會導(dǎo)致阻塞。
繼續(xù)改進(jìn)：將Reactor 拆分為兩部分
上圖為主從NIO模型
如上圖所示，在這種模型下，mainReactor 專門負(fù)責(zé)新客戶端的連接操作，建立通道（channel），然后將一定事件內(nèi)的 channel 注冊到另外一個 subReactor，subReactor 負(fù)責(zé)將客戶端的讀寫請求交給線程池處理。這樣即使幾十萬個請求同時到來也無所謂了。
通俗理解，mainReactor就是大總管，只負(fù)責(zé)接口，subReactor就是一個員工，負(fù)責(zé)給總管接待客戶提供服務(wù)。
Netty線程模型
通過對 《 Scalable IO in Java 》里的一些 IO 處理模式理解， Netty的線程模型就是由上面主從NIO模型演變來的，是基于Reactor模型的。
如下圖所示，Boos Group 就是上面提到的 mainReactor，與上面不同在于 Worker Group，它可以理解為一組 subReactor，即在大總管下面有多個員工來干活，每次接收的客戶都均勻分配給不同員工。Netty 之所以單機(jī)支持百萬級別并發(fā)量，就是因為一主多從的線程模型。
需要說明的是，Netty 的線程模型并不是一成不變的。它通常采用一主多從，但是也可以根據(jù)實際需要配置啟動參數(shù)，通過設(shè)置不同的啟動參數(shù)，Netty 可以同時支持 “多主多從”。
下面是對上圖“一主多從” Netty 模型的詳細(xì)解釋：
Netty 模塊組件
Bootstrap、ServerBootstrap
Bootstrap 意思是引導(dǎo)，一個 Netty 應(yīng)用通常由一個 Bootstrap 開始，主要作用是配置整個 Netty程序，通過鏈?zhǔn)秸{(diào)用串聯(lián)各個組件。Netty 中 Bootstrap 類是客戶端程序的啟動引導(dǎo)類，ServerBootstrap 是服務(wù)端 啟動引導(dǎo)類。
Future、ChannelFuture
正如前面介紹，在 Netty 中所有的 IO 操作都是異步的，不能立刻得知消息是否被正確處理。但是可以過一會等它執(zhí)行完成或者直接注冊一個監(jiān)聽，具體的實現(xiàn)就是通過 Future 和 ChannelFutures，他們可以注冊一個監(jiān)聽，當(dāng)操作執(zhí)行成功或失敗時監(jiān)聽會自動觸發(fā)注冊的監(jiān)聽事件。
Channel
Netty 網(wǎng)絡(luò)通信的組件，能夠用于執(zhí)行網(wǎng)絡(luò) I/O 操作。Channel 為用戶提供：
- NioSocketChannel，異步的客戶端 TCP Socket 連接。（最常用）
- NioServerSocketChannel，異步的服務(wù)器端 TCP Socket 連接
- NioDatagramChannel，異步的 UDP 連接
- NioSctpChannel，異步的客戶端 Sctp 連接
- NioSctpServerChannel，異步的 Sctp 服務(wù)器端連接，這些通道涵蓋了 UDP 和 TCP 網(wǎng)絡(luò) IO 以及文件 IO。
Selector
Netty 基于 Selector 對象實現(xiàn) I/O 多路復(fù)用，通過 Selector 一個線程可以監(jiān)聽多個連接的 Channel 事件。當(dāng)向一個 Selector 中注冊 Channel 后，Selector 內(nèi)部的機(jī)制就可以自動不斷地查詢(Select) 這些注冊的 Channel 是否有已就緒的 I/O 事件（例如可讀，可寫，網(wǎng)絡(luò)連接完成等），這樣程序就可以很簡單地使用一個線程高效地管理多個 Channel 。
NioEventLoop
NioEventLoop 中維護(hù)了一個線程和任務(wù)隊列，支持異步提交執(zhí)行任務(wù)，線程啟動時會調(diào)用 NioEventLoop 的 run 方法，執(zhí)行 I/O 任務(wù)和非 I/O 任務(wù)：
NioEventLoopGroup
NioEventLoopGroup，主要管理 eventLoop 的生命周期，可以理解為一個線程池，內(nèi)部維護(hù)了一組線程，每個線程(NioEventLoop)負(fù)責(zé)處理多個 Channel 上的事件，而一個 Channel 只對應(yīng)于一個線程。
ChannelHandler
ChannelHandler 是一個接口，處理 I/O 事件或攔截 I/O 操作，并將其轉(zhuǎn)發(fā)到其 ChannelPipeline(業(yè)務(wù)處理鏈)中的下一個處理程序。ChannelHandler 本身并沒有提供很多方法，因為這個接口有許多的方法需要實現(xiàn)，方便使用期間，可以繼承它的子類：
- ChannelInboundHandler 用于處理入站 I/O 事件
- ChannelOutboundHandler 用于處理出站 I/O 操作
或者使用以下適配器類：
- ChannelInboundHandlerAdapter 用于處理入站 I/O 事件。
- ChannelOutboundHandlerAdapter 用于處理出站 I/O 操作。
ChannelHandlerContext
保存 Channel 相關(guān)的所有上下文信息，同時關(guān)聯(lián)一個 ChannelHandler 對象。
ChannelPipline
保存 ChannelHandler 的 List，用于處理或攔截 Channel 的入站事件和出站操作。ChannelPipeline 實現(xiàn)了一種高級形式的攔截過濾器模式，使用戶可以完全控制事件的處理方式，以及 Channel 中各個的 ChannelHandler 如何相互交互。在 Netty 中每個 Channel 都有且僅有一個 ChannelPipeline 與之對應(yīng)，它們的組成關(guān)系如下：
一個 Channel 包含了一個 ChannelPipeline，而 ChannelPipeline 中又維護(hù)了一個由 ChannelHandlerContext 組成的雙向鏈表，并且每個 ChannelHandlerContext 中又關(guān)聯(lián)著一個 ChannelHandler。read事件(入站事件)和write事件(出站事件)在一個雙向鏈表中，入站事件會從鏈表 head 往后傳遞到最后一個入站的 handler，出站事件會從鏈表 tail 往前傳遞到最前一個出站的 handler，兩種類型的 handler 互不干擾。
Netty通訊示例
Netty的maven依賴
io.netty netty-all 4.1.52.Final
服務(wù)端代碼
- package com.niuh.netty.base;
- import io.netty.bootstrap.ServerBootstrap;
- import io.netty.channel.ChannelFuture;
- 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.NioServerSocketChannel;
- public class NettyServer {
- public static void main(String[] args) throws Exception {
- //創(chuàng)建兩個線程組bossGroup和workerGroup, 含有的子線程N(yùn)ioEventLoop的個數(shù)默認(rèn)為cpu核數(shù)的兩倍
- // bossGroup只是處理連接請求 ,真正的和客戶端業(yè)務(wù)處理，會交給workerGroup完成
- EventLoopGroup bossGroup = new NioEventLoopGroup(1);
- EventLoopGroup workerGroup = new NioEventLoopGroup();
- try {
- //創(chuàng)建服務(wù)器端的啟動對象
- ServerBootstrap bootstrap = new ServerBootstrap();
- //使用鏈?zhǔn)骄幊虂砼渲脜?shù)
- bootstrap.group(bossGroup, workerGroup) //設(shè)置兩個線程組
- .channel(NioServerSocketChannel.class) //使用NioServerSocketChannel作為服務(wù)器的通道實現(xiàn)
- // 初始化服務(wù)器連接隊列大小，服務(wù)端處理客戶端連接請求是順序處理的,所以同一時間只能處理一個客戶端連接。
- // 多個客戶端同時來的時候,服務(wù)端將不能處理的客戶端連接請求放在隊列中等待處理
- .option(ChannelOption.SO_BACKLOG, 1024)
- .childHandler(new ChannelInitializer
() {//創(chuàng)建通道初始化對象，設(shè)置初始化參數(shù) - @Override
- protected void initChannel(SocketChannel ch) throws Exception {
- //對workerGroup的SocketChannel設(shè)置處理器
- ch.pipeline().addLast(new NettyServerHandler());
- }
- });
- System.out.println("netty server start。");
- //綁定一個端口并且同步, 生成了一個ChannelFuture異步對象，通過isDone()等方法可以判斷異步事件的執(zhí)行情況
- //啟動服務(wù)器(并綁定端口)，bind是異步操作，sync方法是等待異步操作執(zhí)行完畢
- ChannelFuture cf = bootstrap.bind(9000).sync();
- //給cf注冊監(jiān)聽器，監(jiān)聽我們關(guān)心的事件
- /*cf.addListener(new ChannelFutureListener() {
- @Override
- public void operationComplete(ChannelFuture future) throws Exception {
- if (cf.isSuccess()) {
- System.out.println("監(jiān)聽端口9000成功");
- } else {
- System.out.println("監(jiān)聽端口9000失敗");
- }
- }
- });*/
- //對通道關(guān)閉進(jìn)行監(jiān)聽，closeFuture是異步操作，監(jiān)聽通道關(guān)閉
- // 通過sync方法同步等待通道關(guān)閉處理完畢，這里會阻塞等待通道關(guān)閉完成
- cf.channel().closeFuture().sync();
- } finally {
- bossGroup.shutdownGracefully();
- workerGroup.shutdownGracefully();
- }
- }
- }
服務(wù)端所注冊的自定義回調(diào)函數(shù) NettyServerHandler：
- package com.niuh.netty.base;
- import io.netty.buffer.ByteBuf;
- import io.netty.buffer.Unpooled;
- import io.netty.channel.ChannelHandlerContext;
- import io.netty.channel.ChannelInboundHandlerAdapter;
- import io.netty.util.CharsetUtil;
- /**
- * 自定義Handler需要繼承netty規(guī)定好的某個HandlerAdapter(規(guī)范)
- */
- public class NettyServerHandler extends ChannelInboundHandlerAdapter {
- /**
- * 讀取客戶端發(fā)送的數(shù)據(jù)
- *
- * @param ctx 上下文對象, 含有通道channel，管道pipeline
- * @param msg 就是客戶端發(fā)送的數(shù)據(jù)
- * @throws Exception
- */
- @Override
- public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
- System.out.println("服務(wù)器讀取線程 " + Thread.currentThread().getName());
- //Channel channel = ctx.channel();
- //ChannelPipeline pipeline = ctx.pipeline(); //本質(zhì)是一個雙向鏈接, 出站入站
- //將 msg 轉(zhuǎn)成一個 ByteBuf，類似NIO 的 ByteBuffer
- ByteBuf buf = (ByteBuf) msg;
- System.out.println("客戶端發(fā)送消息是:" + buf.toString(CharsetUtil.UTF_8));
- }
- /**
- * 數(shù)據(jù)讀取完畢處理方法
- *
- * @param ctx
- * @throws Exception
- */
- @Override
- public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
- ByteBuf buf = Unpooled.copiedBuffer("HelloClient".getBytes(CharsetUtil.UTF_8));
- ctx.writeAndFlush(buf);
- }
- /**
- * 處理異常, 一般是需要關(guān)閉通道
- *
- * @param ctx
- * @param cause
- * @throws Exception
- */
- @Override
- public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
- ctx.close();
- }
- }
這個類繼承了ChannelInboundHandlerAdapter的幾個方法：
客戶端代碼
- package com.niuh.netty.base;
- import io.netty.bootstrap.Bootstrap;
- import io.netty.channel.ChannelFuture;
- import io.netty.channel.ChannelInitializer;
- import io.netty.channel.EventLoopGroup;
- import io.netty.channel.nio.NioEventLoopGroup;
- import io.netty.channel.socket.SocketChannel;
- import io.netty.channel.socket.nio.NioSocketChannel;
- public class NettyClient {
- public static void main(String[] args) throws Exception {
- //客戶端需要一個事件循環(huán)組
- EventLoopGroup group = new NioEventLoopGroup();
- try {
- //創(chuàng)建客戶端啟動對象
- //注意客戶端使用的不是ServerBootstrap而是Bootstrap
- Bootstrap bootstrap = new Bootstrap();
- //設(shè)置相關(guān)參數(shù)
- bootstrap.group(group) //設(shè)置線程組
- .channel(NioSocketChannel.class) // 使用NioSocketChannel作為客戶端的通道實現(xiàn)
- .handler(new ChannelInitializer
() { - @Override
- protected void initChannel(SocketChannel ch) throws Exception {
- //加入處理器
- ch.pipeline().addLast(new NettyClientHandler());
- }
- });
- System.out.println("netty client start。");
- //啟動客戶端去連接服務(wù)器端
- ChannelFuture cf = bootstrap.connect("127.0.0.1", 9000).sync();
- //對通道關(guān)閉進(jìn)行監(jiān)聽
- cf.channel().closeFuture().sync();
- } finally {
- group.shutdownGracefully();
- }
- }
- }
客戶端自定義回調(diào)函數(shù)：
- package com.niuh.netty.base;
- import io.netty.buffer.ByteBuf;
- import io.netty.buffer.Unpooled;
- import io.netty.channel.ChannelHandlerContext;
- import io.netty.channel.ChannelInboundHandlerAdapter;
- import io.netty.util.CharsetUtil;
- public class NettyClientHandler extends ChannelInboundHandlerAdapter {
- /**
- * 當(dāng)客戶端連接服務(wù)器完成就會觸發(fā)該方法
- *
- * @param ctx
- * @throws Exception
- */
- @Override
- public void channelActive(ChannelHandlerContext ctx) throws Exception {
- ByteBuf buf = Unpooled.copiedBuffer("HelloServer".getBytes(CharsetUtil.UTF_8));
- ctx.writeAndFlush(buf);
- }
- //當(dāng)通道有讀取事件時會觸發(fā)，即服務(wù)端發(fā)送數(shù)據(jù)給客戶端
- @Override
- public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
- ByteBuf buf = (ByteBuf) msg;
- System.out.println("收到服務(wù)端的消息:" + buf.toString(CharsetUtil.UTF_8));
- System.out.println("服務(wù)端的地址： " + ctx.channel().remoteAddress());
- }
- @Override
- public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
- cause.printStackTrace();
- ctx.close();
- }
- }
與NettyServerHandler類似，其中的channelActive（）方法是當(dāng)客戶端與服務(wù)器連接完成時候就會執(zhí)行的方法。
看完代碼，我們發(fā)現(xiàn)Netty架的目標(biāo)就是讓你的業(yè)務(wù)邏輯從網(wǎng)絡(luò)基礎(chǔ)應(yīng)用編碼中分離出來，讓你可以專 注業(yè)務(wù)的開發(fā)，而不需寫一大堆類似NIO的網(wǎng)絡(luò)處理操作。
ByteBuf 理解
從結(jié)構(gòu)上來說，ByteBuf 由一串字節(jié)數(shù)組構(gòu)成。數(shù)組中每個字節(jié)用來存放信息。
ByteBuf 提供了兩個索引，一個用于讀取數(shù)據(jù)，一個用于寫入數(shù)據(jù)。這兩個索引通過在字節(jié)數(shù)組中移動，來定位需要讀或者寫信息的位置。
ByteBuf.png
需要注意的是極限的情況是 readerIndex 剛好讀到了 writerIndex 寫入的地方。如果 readerIndex 超過了 writerIndex 的時候，Netty 會拋出 IndexOutOf-BoundsException 異常。
示例代碼
- package com.niuh.netty.base;
- import io.netty.buffer.ByteBuf;
- import io.netty.buffer.Unpooled;
- import io.netty.util.CharsetUtil;
- public class NettyByteBuf {
- public static void main(String[] args) {
- // 創(chuàng)建byteBuf對象，該對象內(nèi)部包含一個字節(jié)數(shù)組byte[10]
- // 通過readerindex和writerIndex和capacity，將buffer分成三個區(qū)域
- // 已經(jīng)讀取的區(qū)域：[0,readerindex)
- // 可讀取的區(qū)域：[readerindex,writerIndex)
- // 可寫的區(qū)域: [writerIndex,capacity)
- ByteBuf byteBuf = Unpooled.buffer(10);
- System.out.println("byteBuf=" + byteBuf);
- for (int i = 0; i < 8; i++) {
- byteBuf.writeByte(i);
- }
- System.out.println("byteBuf=" + byteBuf);
- for (int i = 0; i < 5; i++) {
- System.out.println(byteBuf.getByte(i));
- }
- System.out.println("byteBuf=" + byteBuf);
- for (int i = 0; i < 5; i++) {
- System.out.println(byteBuf.readByte());
- }
- System.out.println("byteBuf=" + byteBuf);
- //用Unpooled工具類創(chuàng)建ByteBuf
- ByteBuf byteBuf2 = Unpooled.copiedBuffer("hello,zhangsan!", CharsetUtil.UTF_8);
- //使用相關(guān)的方法
- if (byteBuf2.hasArray()) {
- byte[] content = byteBuf2.array();
- //將 content 轉(zhuǎn)成字符串
- System.out.println(new String(content, CharsetUtil.UTF_8));
- System.out.println("byteBuf=" + byteBuf2);
- System.out.println(byteBuf2.readerIndex()); // 0
- System.out.println(byteBuf2.writerIndex()); // 12
- System.out.println(byteBuf2.capacity()); // 36
- System.out.println(byteBuf2.getByte(0)); // 獲取數(shù)組0這個位置的字符h的ascii碼，h=104
- int len = byteBuf2.readableBytes(); //可讀的字節(jié)數(shù) 12
- System.out.println("len=" + len);
- //使用for取出各個字節(jié)
- for (int i = 0; i < len; i++) {
- System.out.println((char) byteBuf2.getByte(i));
- }
- //范圍讀取
- System.out.println(byteBuf2.getCharSequence(0, 6, CharsetUtil.UTF_8));
- System.out.println(byteBuf2.getCharSequence(6, 6, CharsetUtil.UTF_8));
- }
- }
- }
PS：以上代碼提交在 Github ：https://github.com/Niuh-Study/niuh-netty.git
我們在微信上24小時期待你的聲音
解答本文疑問/技術(shù)咨詢/運營咨詢/技術(shù)建議/互聯(lián)網(wǎng)交流
微信二維碼
微信二維碼
移動版官網(wǎng)