《跟闪电侠学Netty》开篇:Netty是什么?

Posted 闪电侠的博客

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了《跟闪电侠学Netty》开篇:Netty是什么?相关的知识,希望对你有一定的参考价值。

在开始了解Netty是什么之前,我们先来回顾一下,如果我们需要实现一个客户端与服务端通信的程序,使用传统的IO编程,应该如何来实现?

IO编程

我们简化下场景:客户端每隔两秒发送一个带有时间戳的"hello world"给服务端,服务端收到之后打印。

为了方便演示,下面例子中,服务端和客户端各一个类,把这两个类拷贝到你的IDE中,先后运行 ioserver.java和 IOClient.java可看到效果。

下面是传统的IO编程中服务端实现

IOServer.java

 
   
   
 
  1. /**

  2. * @author 闪电侠

  3. */

  4. public class IOServer {

  5.    public static void main(String[] args) throws Exception {

  6.        ServerSocket serverSocket = new ServerSocket(8000);

  7.        // (1) 接收新连接线程

  8.        new Thread(() -> {

  9.            while (true) {

  10.                try {

  11.                    // (1) 阻塞方法获取新的连接

  12.                    Socket socket = serverSocket.accept();

  13.                    // (2) 每一个新的连接都创建一个线程,负责读取数据

  14.                    new Thread(() -> {

  15.                        try {

  16.                            byte[] data = new byte[1024];

  17.                            InputStream inputStream = socket.getInputStream();

  18.                            while (true) {

  19.                                int len;

  20.                                // (3) 按字节流方式读取数据

  21.                                while ((len = inputStream.read(data)) != -1) {

  22.                                    System.out.println(new String(data, 0, len));

  23.                                }

  24.                            }

  25.                        } catch (IOException e) {

  26.                        }

  27.                    }).start();

  28.                } catch (IOException e) {

  29.                }

  30.            }

  31.        }).start();

  32.    }

  33. }

server端首先创建了一个 serverSocket来监听8000端口,然后创建一个线程,线程里面不断调用阻塞方法 serversocket.accept();获取新的连接,见(1),当获取到新的连接之后,给每条连接创建一个新的线程,这个线程负责从该连接中读取数据,见(2),然后读取数据是以字节流的方式,见(3)。

下面是传统的IO编程中客户端实现

IOClient.java

 
   
   
 
  1. /**

  2. * @author 闪电侠

  3. */

  4. public class IOClient {

  5.    public static void main(String[] args) {

  6.        new Thread(() -> {

  7.            try {

  8.                Socket socket = new Socket("127.0.0.1", 8000);

  9.                while (true) {

  10.                    try {

  11.                        socket.getOutputStream().write((new Date() + ": hello world").getBytes());

  12.                        socket.getOutputStream().flush();

  13.                        Thread.sleep(2000);

  14.                    } catch (Exception e) {

  15.                    }

  16.                }

  17.            } catch (IOException e) {

  18.            }

  19.        }).start();

  20.    }

  21. }

客户端的代码相对简单,连接上服务端8000端口之后,每隔2秒,我们向服务端写一个带有时间戳的 "hello world"。

IO编程模型在客户端较少的情况下运行良好,但是对于客户端比较多的业务来说,单机服务端可能需要支撑成千上万的连接,IO模型可能就不太合适了,我们来分析一下原因。

上面的demo,从服务端代码中我们可以看到,在传统的IO模型中,每个连接创建成功之后都需要一个线程来维护,每个线程包含一个while死循环,那么1w个连接对应1w个线程,继而1w个while死循环,这就带来如下几个问题:

  1. 线程资源受限:线程是操作系统中非常宝贵的资源,同一时刻有大量的线程处于阻塞状态是非常严重的资源浪费,操作系统耗不起

  2. 线程切换效率低下:单机cpu核数固定,线程爆炸之后操作系统频繁进行线程切换,应用性能急剧下降。

  3. 除了以上两个问题,IO编程中,我们看到数据读写是以字节流为单位,效率不高。

为了解决这三个问题,JDK在1.4之后提出了NIO。

NIO编程

关于NIO相关的文章网上也有很多,这里不打算详细深入分析,下面简单描述一下NIO是如何解决以上三个问题的。

线程资源受限

NIO编程模型中,新来一个连接不再创建一个新的线程,而是可以把这条连接直接绑定到某个固定的线程,然后这条连接所有的读写都由这个线程来负责,那么他是怎么做到的?我们用一幅图来对比一下IO与NIO

如上图所示,IO模型中,一个连接来了,会创建一个线程,对应一个while死循环,死循环的目的就是不断监测这条连接上是否有数据可以读,大多数情况下,1w个连接里面同一时刻只有少量的连接有数据可读,因此,很多个while死循环都白白浪费掉了,因为读不出啥数据。

而在NIO模型中,他把这么多while死循环变成一个死循环,这个死循环由一个线程控制,那么他又是如何做到一个线程,一个while死循环就能监测1w个连接是否有数据可读的呢? 这就是NIO模型中selector的作用,一条连接来了之后,现在不创建一个while死循环去监听是否有数据可读了,而是直接把这条连接注册到selector上,然后,通过检查这个selector,就可以批量监测出有数据可读的连接,进而读取数据,下面我再举个非常简单的生活中的例子说明IO与NIO的区别。

在一家幼儿园里,小朋友有上厕所的需求,小朋友都太小以至于你要问他要不要上厕所,他才会告诉你。幼儿园一共有100个小朋友,有两种方案可以解决小朋友上厕所的问题:

  1. 每个小朋友配一个老师。每个老师隔段时间询问小朋友是否要上厕所,如果要上,就领他去厕所,100个小朋友就需要100个老师来询问,并且每个小朋友上厕所的时候都需要一个老师领着他去上,这就是IO模型,一个连接对应一个线程。

  2. 所有的小朋友都配同一个老师。这个老师隔段时间询问所有的小朋友是否有人要上厕所,然后每一时刻把所有要上厕所的小朋友批量领到厕所,这就是NIO模型,所有小朋友都注册到同一个老师,对应的就是所有的连接都注册到一个线程,然后批量轮询。

这就是NIO模型解决线程资源受限的方案,实际开发过程中,我们会开多个线程,每个线程都管理着一批连接,相对于IO模型中一个线程管理一条连接,消耗的线程资源大幅减少

线程切换效率低下

由于NIO模型中线程数量大大降低,线程切换效率因此也大幅度提高

IO读写以字节为单位

NIO解决这个问题的方式是数据读写不再以字节为单位,而是以字节块为单位。IO模型中,每次都是从操作系统底层一个字节一个字节地读取数据,而NIO维护一个缓冲区,每次可以从这个缓冲区里面读取一块的数据, 这就好比一盘美味的豆子放在你面前,你用筷子一个个夹(每次一个),肯定不如要勺子挖着吃(每次一批)效率来得高。

简单讲完了JDK NIO的解决方案之后,我们接下来使用NIO的方案替换掉IO的方案,我们先来看看,如果用JDK原生的NIO来实现服务端,该怎么做

前方高能预警:以下代码可能会让你感觉极度不适,如有不适,请跳过

NIOServer.java

 
   
   
 
  1. /**

  2. * @author 闪电侠

  3. */

  4. public class NIOServer {

  5.    public static void main(String[] args) throws IOException {

  6.        Selector serverSelector = Selector.open();

  7.        Selector clientSelector = Selector.open();

  8.        new Thread(() -> {

  9.            try {

  10.                // 对应IO编程中服务端启动

  11.                ServerSocketChannel listenerChannel = ServerSocketChannel.open();

  12.                listenerChannel.socket().bind(new InetSocketAddress(8000));

  13.                listenerChannel.configureBlocking(false);

  14.                listenerChannel.register(serverSelector, SelectionKey.OP_ACCEPT);

  15.                while (true) {

  16.                    // 监测是否有新的连接,这里的1指的是阻塞的时间为1ms

  17.                    if (serverSelector.select(1) > 0) {

  18.                        Set<SelectionKey> set = serverSelector.selectedKeys();

  19.                        Iterator<SelectionKey> keyIterator = set.iterator();

  20.                        while (keyIterator.hasNext()) {

  21.                            SelectionKey key = keyIterator.next();

  22.                            if (key.isAcceptable()) {

  23.                                try {

  24.                                    // (1) 每来一个新连接,不需要创建一个线程,而是直接注册到clientSelector

  25.                                    SocketChannel clientChannel = ((ServerSocketChannel) key.channel()).accept();

  26.                                    clientChannel.configureBlocking(false);

  27.                                    clientChannel.register(clientSelector, SelectionKey.OP_READ);

  28.                                } finally {

  29.                                    keyIterator.remove();

  30.                                }

  31.                            }

  32.                        }

  33.                    }

  34.                }

  35.            } catch (IOException ignored) {

  36.            }

  37.        }).start();

  38.        new Thread(() -> {

  39.            try {

  40.                while (true) {

  41.                    // (2) 批量轮询是否有哪些连接有数据可读,这里的1指的是阻塞的时间为1ms

  42.                    if (clientSelector.select(1) > 0) {

  43.                        Set<SelectionKey> set = clientSelector.selectedKeys();

  44.                        Iterator<SelectionKey> keyIterator = set.iterator();

  45.                        while (keyIterator.hasNext()) {

  46.                            SelectionKey key = keyIterator.next();

  47.                            if (key.isReadable()) {

  48.                                try {

  49.                                    SocketChannel clientChannel = (SocketChannel) key.channel();

  50.                                    ByteBuffer byteBuffer = ByteBuffer.allocate(1024);

  51.                                    // (3) 读取数据以块为单位批量读取

  52.                                    clientChannel.read(byteBuffer);

  53.                                    byteBuffer.flip();

  54.                                    System.out.println(Charset.defaultCharset().newDecoder().decode(byteBuffer)

  55.                                            .toString());

  56.                                } finally {

  57.                                    keyIterator.remove();

  58.                                    key.interestOps(SelectionKey.OP_READ);

  59.                                }

  60.                            }

  61.                        }

  62.                    }

  63.                }

  64.            } catch (IOException ignored) {

  65.            }

  66.        }).start();

  67.    }

  68. }

相信大部分没有接触过NIO的同学应该会直接跳过代码来到这一行:原来使用JDK原生NIO的API实现一个简单的服务端通信程序是如此复杂!

复杂得我都没耐心解释这一坨代码的执行逻辑(开个玩笑),我们还是先对照NIO来解释一下几个核心思路

  1. NIO模型中通常会有两个线程,每个线程绑定一个轮询器selector,在我们这个例子中 serverSelector负责轮询是否有新的连接, clientSelector负责轮询连接是否有数据可读

  2. 服务端监测到新的连接之后,不再创建一个新的线程,而是直接将新连接绑定到 clientSelector上,这样就不用IO模型中1w个while循环在死等,参见(1)

  3. clientSelector被一个while死循环包裹着,如果在某一时刻有多条连接有数据可读,那么通过 clientSelector.select(1)方法可以轮询出来,进而批量处理,参见(2)

  4. 数据的读写以内存块为单位,参见(3)

其他的细节部分,我不愿意多讲,因为实在是太复杂,你也不用对代码的细节深究到底。总之,强烈不建议直接基于JDK原生NIO来进行网络开发,下面是我总结的原因

1、JDK的NIO编程需要了解很多的概念,编程复杂,对NIO入门非常不友好,编程模型不友好,ByteBuffer的api简直反人类 2、对NIO编程来说,一个比较合适的线程模型能充分发挥它的优势,而JDK没有给你实现,你需要自己实现,就连简单的自定义协议拆包都要你自己实现 3、JDK的NIO底层由epoll实现,该实现饱受诟病的空轮训bug会导致cpu飙升100% 4、项目庞大之后,自行实现的NIO很容易出现各类bug,维护成本较高,上面这一坨代码我都不能保证没有bug

正因为如此,我客户端代码都懒得写给你看了==!,你可以直接使用 IOClient.java与 NIOServer.java通信

JDK的NIO犹如带刺的玫瑰,虽然美好,让人向往,但是使用不当会让你抓耳挠腮,痛不欲生,正因为如此,Netty横空出世!

Netty编程

那么Netty到底是何方神圣? 用一句简单的话来说就是:Netty封装了JDK的NIO,让你用得更爽,你不用再写一大堆复杂的代码了。 用官方正式的话来说就是:Netty是一个异步事件驱动的网络应用框架,用于快速开发可维护的高性能服务器和客户端。

下面是我总结的使用Netty不使用JDK原生NIO的原因

  1. 使用JDK自带的NIO需要了解太多的概念,编程复杂,一不小心bug横飞

  2. Netty底层IO模型随意切换,而这一切只需要做微小的改动,改改参数,Netty可以直接从NIO模型变身为IO模型

  3. Netty自带的拆包解包,异常检测等机制让你从NIO的繁重细节中脱离出来,让你只需要关心业务逻辑

  4. Netty解决了JDK的很多包括空轮询在内的bug

  5. Netty底层对线程,selector做了很多细小的优化,精心设计的reactor线程模型做到非常高效的并发处理

  6. 自带各种协议栈让你处理任何一种通用协议都几乎不用亲自动手

  7. Netty社区活跃,遇到问题随时邮件列表或者issue

  8. Netty已经历各大rpc框架,消息中间件,分布式通信中间件线上的广泛验证,健壮性无比强大

看不懂没有关系,这些我们在后续的课程中我们都可以学到,接下来我们用Netty的版本来重新实现一下本文开篇的功能吧

首先,引入Maven依赖

 
   
   
 
  1.    <dependency>

  2.        <groupId>io.netty</groupId>

  3.        <artifactId>netty-all</artifactId>

  4.        <version>4.1.6.Final</version>

  5.    </dependency>

然后,下面是服务端实现部分

NettyServer.java

 
   
   
 
  1. /**

  2. * @author 闪电侠

  3. */

  4. public class NettyServer {

  5.    public static void main(String[] args) {

  6.        ServerBootstrap serverBootstrap = new ServerBootstrap();

  7.        NioEventLoopGroup boos = new NioEventLoopGroup();

  8.        NioEventLoopGroup worker = new NioEventLoopGroup();

  9.        serverBootstrap

  10.                .group(boos, worker)

  11.                .channel(NioServerSocketChannel.class)

  12.                .childHandler(new ChannelInitializer<NioSocketChannel>() {

  13.                    protected void initChannel(NioSocketChannel ch) {

  14.                        ch.Pipeline().addLast(new StringDecoder());

  15.                        ch.Pipeline().addLast(new SimpleChannelInboundHandler<String>() {

  16.                            @Override

  17.                            protected void channelRead0(ChannelHandlerContext ctx, String msg) {

  18.                                System.out.println(msg);

  19.                            }

  20.                        });

  21.                    }

  22.                })

  23.                .bind(8000);

  24.    }

  25. }

这么一小段代码就实现了我们前面NIO编程中的所有的功能,包括服务端启动,接受新连接,打印客户端传来的数据,怎么样,是不是比JDK原生的NIO编程优雅许多?

初学Netty的时候,由于大部分人对NIO编程缺乏经验,因此,将Netty里面的概念与IO模型结合起来可能更好理解

1. boos对应了 IOServer.java中的接收新连接线程,主要负责创建新连接 2. worker对应 IOClient.java中的负责读取数据的线程,主要用于读取数据以及业务逻辑处理

然后剩下的逻辑我在后面的系列文章中会详细分析,你可以先把这段代码拷贝到你的IDE里面,然后运行main函数

然后下面是客户端NIO的实现部分

NettyClient.java

 
   
   
 
  1. /**

  2. * @author 闪电侠

  3. */

  4. public class NettyClient {

  5.    public static void main(String[] args) throws InterruptedException {

  6.        Bootstrap bootstrap = new Bootstrap();

  7.        NioEventLoopGroup group = new NioEventLoopGroup();

  8.        bootstrap.group(group)

  9.                .channel(NioSocketChannel.class)

  10.                .handler(new ChannelInitializer<Channel>() {

  11.                    @Override

  12.                    protected void initChannel(Channel ch) {

  13.                        ch.Pipeline().addLast(new StringEncoder());

  14.                    }

  15.                });

  16.        Channel channel = bootstrap.connect("127.0.0.1", 8000).channel();

  17.        while (true) {

  18.            channel.writeAndFlush(new Date() + ": hello world!");

  19.            Thread.sleep(2000);

  20.        }

  21.    }

  22. }

在客户端程序中, group对应了我们 IOClient.java中main函数起的线程,剩下的逻辑我在后面的文章中会详细分析,现在你要做的事情就是把这段代码拷贝到你的IDE里面,然后运行main函数,最后回到 NettyIOServer.java的控制台,你会看到效果。

使用Netty之后是不是觉得整个世界都美好了,一方面Netty对NIO封装得如此完美,写出来的代码非常优雅,另外一方面,使用Netty之后,网络通信这块的性能问题几乎不用操心,尽情地让Netty榨干你的CPU吧。

目前我负责的两大长连接项目均峰值QPS在50W左右,单机连接数10W左右,集群规模在千万级别,底层均使用了Netty作为通信框架。Netty如此高性能及稳定的特性让我几乎不用为性能而担忧,所以,如果你工作中需要接触到网络编程,Netty必将是你的最佳选择!在后续的文章中,我将基于一个简单的消息推送系统带领你从0到1系统学习Netty各方面的知识,并且每一篇文章都会有一个视频课程对应,每一篇文章对应源码我也会放到github上。

如果你没有学习过Netty,那么本系列将会是你零基础入门最好的资料,如果你对Netty有所掌握,想深入了解Netty的细节,摸透Netty的底层原理,那么我的源码分析视频(imooc.com搜索"Netty")将会是你最好的选择,截止目前,已经有200多位小伙伴加入。

附录 《跟闪电侠学Netty》目录,不定期更新,欢迎关注

  • 《跟闪电侠学Netty》01: 服务端启动流程介绍 [图文+视频]

  • 《跟闪电侠学Netty》02: 客户端启动流程介绍 [图文+视频]

  • 《跟闪电侠学Netty》03: Pipeline及ChannelHandler介绍及其分类 [图文+视频]

  • 《跟闪电侠学Netty》04: ChannelInboundHandler及其生命周期 [图文+视频]

  • 《跟闪电侠学Netty》05: ChannelOutBoundHandler及其生命周期 [图文+视频]

  • 《跟闪电侠学Netty》06: Pipeline的inbound事件传播机制 [图文+视频]

  • 《跟闪电侠学Netty》07: Pipeline的outbound事件传播机制 [图文+视频]

  • 《跟闪电侠学Netty》08: Pipeline的异常传播机制 [图文+视频]

  • 《跟闪电侠学Netty》09: 数据传输载体ByteBuf介绍 [图文+视频]

  • 《跟闪电侠学Netty》10: ByteBuf三维度分类 [图文+视频]

  • 《跟闪电侠学Netty》11: ByteBuf分配器介绍 [图文+视频]

  • 《跟闪电侠学Netty》12: 客户端与服务端简单通信 [图文+视频]

  • 《跟闪电侠学Netty》13: 服务端粘包问题以及解决方案 [图文+视频]

  • 《跟闪电侠学Netty》14: 服务端发送push, 基于MessageToByteEncoder实现自定义编码器 [图文+视频]

  • 《跟闪电侠学Netty》15: 编码转换器MessageToMessageEncoder介绍 [图文+视频]

  • 《跟闪电侠学Netty》16: 客户端收push, 基于ByteToMessageDecoder实现自定义协议解码器 [图文+视频]

  • 《跟闪电侠学Netty》17: 解码转换器MessageToMessageDecoder [图文+视频]

  • 《跟闪电侠学Netty》18: 客户端发送ack与服务端处理ack [图文+视频]

  • 《跟闪电侠学Netty》19: Netty中的异步处理及回调机制 [图文+视频]

  • 《跟闪电侠学Netty》20: NioEventLoop以及业务线程隔离 [图文+视频]

  • 《跟闪电侠学Netty》21: NioEventLoop实现客户端定时心跳 [图文+视频]

  • 《跟闪电侠学Netty》22: 服务端空闲监测与超时关闭客户端连接 [图文+视频]

  • 《跟闪电侠学Netty》23: 编写一个WebSocket应用程序[视频]

  • 《跟闪电侠学Netty》24: 编写一个Http Proxy与性能优化[视频]

  • 《跟闪电侠学Netty》25: 编写一个简单的RPC通信服务[视频]

  • 《跟闪电侠学Netty》26: Netty性能优化最佳实践 [视频]

以上是关于《跟闪电侠学Netty》开篇:Netty是什么?的主要内容,如果未能解决你的问题,请参考以下文章

Netty 核心源码解读 —— 开篇

开篇:Netty源码学习系列

Java读源码之Netty深入剖析

Netty实战:netty 堆外内存泄露排查盛宴

netty : websocketx.WebSocketHandshakeException: not a WebSocket handshake request: missing upgrade(代

SofaRpc源码学习篇-netty以及跟dubbo骚操作,负载均衡