版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/pyycsd/article/details/103041045
在开始了解Netty是什么之前,我们先来回顾一下,如果我们需要实现一个客户端与服务端通信的程序,使用传统的IO编程,应该如何来实现?
示例: 客户端每隔两秒发送一个带有时间戳的"hello world"给服务端,服务端收到之后打印。
IOServer.java:
public class IOServer {
public static void main(String[] args) throws Exception {
ServerSocket serverSocket = new ServerSocket(8000);
// (1) 接收新连接线程
new Thread(() -> {
while (true) {
try {
// (1) 阻塞方法获取新的连接
Socket socket = serverSocket.accept();
// (2) 每一个新的连接都创建一个线程,负责读取数据
new Thread(() -> {
try {
byte[] data = new byte[1024];
InputStream inputStream = socket.getInputStream();
while (true) {
int len;
// (3) 按字节流方式读取数据
while ((len = inputStream.read(data)) != -1) {
System.out.println(new String(data, 0, len));
}
}
} catch (IOException e) {
}
}).start();
} catch (IOException e) {
}
}
}).start();
}
}
server端首先创建一个 serverSocket
来监听8000端口,然后创建一个线程,线程里面不断调用阻塞方法 serverSocket.accept()
获取新的连接,见(1),当获取到新的连接之后,给每条连接创建一个新的线程,这个线程负责从该连接中读取数据,见(2),然后读取数据是以字节流的方式见(3)。
public class IOClient {
public static void main(String[] args) {
new Thread(() -> {
try {
Socket socket = new Socket("127.0.0.1", 8000);
while (true) {
try {
socket.getOutputStream().write((new Date() + ": hello world").getBytes());
socket.getOutputStream().flush();
Thread.sleep(2000);
} catch (Exception e) {
}
}
} catch (IOException e) {
}
}).start();
}
}
客户端的代码相对简单,连接上服务端 8000 端口之后,每隔2秒,向客户端写一个带有时间戳的 “hello world”。
IO编程模型在客户端较少的情况下运行良好,但是对于客户端比较多的业务来说,单机服务端可能需要支撑成千上万的连接,IO模型可能就不太合适了,我们来分析下原因。
上面的Demo,从服务端代码中我们可以看到,在传统IO模型中,每个连接创建成功之后都需要一个线程来维护,每个线程包括一个while死循环,那么1w个连接对应1w个线程,继而1w个while死循环,这就带来如下几个问题:
字节
为单位,效率不高。为了解决这三个问题,JDK1.4之后提出了 NIO。
关于NIO相关的文章网上也有很多,这里不打算详细深入分析,下面简单描述一下NIO是如何解决以上三个问题的。
如上图所示,IO模型中,一个连接来了,会创建一个线程,对应一个while死循环,死循环的目的就是不断检测这条连接上是否有数据可以读,大多数情况下,1w个连接里面同一时刻只要少量的连接有数据可读,因此,很多个while死循环都白白浪费掉了,因为读不出啥数据。
而在NIO模型中,它把这么多while死循环编程一个死循环,这个死循环有一个线程控制,那么它又是如何做到一个线程,一个while死循环就能检测1w个连接是否有数据可读呢?
这就是NIO模型中的 selector
作用,一个连接来了之后,先不创建一个while死循环去监听是否有数据可读了,而是直接把这条连接注册到 selector
上,然后,通过检测这个 selector,就可以批量检测出有数据可读的连接,进而读取数据,下面我们在举个简单的例子说明下IO与NIO的区别。
这就是NIO模型解决线程资源受限的方案,实际开发过程中,我们会开多个线程,每个线程都管理一批连接,相对于IO模型中一个线程管理一条连接,消耗的线程资源大幅减少。
字节
为单位,而是以字节快
为单位。IO模型中,每次都是从操作系统底层一个字节一个字节地读取数据,而NIO维护一个缓冲区,每次都可以从这个缓冲区里面读取一块的数据。这就好比一盘美味的豆子放在你面前,你用筷子一个个夹(每次一个),肯定不如用勺子挖着吃(每次一批)效率来的高。
简单讲完了JDK NIO的解决方案之后,我们接下来使用NIO的方案替换掉IO的方案,我们先来看看,如果用JDK原生的NIO来实现服务端,该怎么做
前方高能预警:以下代码可能会让你感觉极度不适,如有不适,请跳过
NIOServer.java
public class NIOServer {
public static void main(String[] args) throws IOException {
Selector serverSelector = Selector.open();
Selector clientSelector = Selector.open();
new Thread(() -> {
try {
// 对应IO编程中服务端启动
ServerSocketChannel listenerChannel = ServerSocketChannel.open();
listenerChannel.socket().bind(new InetSocketAddress(8000));
listenerChannel.configureBlocking(false);
listenerChannel.register(serverSelector, SelectionKey.OP_ACCEPT);
while (true) {
// 监测是否有新的连接,这里的1指的是阻塞的时间为1ms
if (serverSelector.select(1) > 0) {
Set<SelectionKey> set = serverSelector.selectedKeys();
Iterator<SelectionKey> keyIterator = set.iterator();
while (keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();
if (key.isAcceptable()) {
try {
// (1) 每来一个新连接,不需要创建一个线程,而是直接注册到clientSelector
SocketChannel clientChannel = ((ServerSocketChannel) key.channel()).accept();
clientChannel.configureBlocking(false);
clientChannel.register(clientSelector, SelectionKey.OP_READ);
} finally {
keyIterator.remove();
}
}
}
}
}
} catch (IOException ignored) {
}
}).start();
new Thread(() -> {
try {
while (true) {
// (2) 批量轮询是否有哪些连接有数据可读,这里的1指的是阻塞的时间为1ms
if (clientSelector.select(1) > 0) {
Set<SelectionKey> set = clientSelector.selectedKeys();
Iterator<SelectionKey> keyIterator = set.iterator();
while (keyIterator.hasNext()) {
SelectionKey key = keyIterator.next();
if (key.isReadable()) {
try {
SocketChannel clientChannel = (SocketChannel) key.channel();
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
// (3) 读取数据以块为单位批量读取
clientChannel.read(byteBuffer);
byteBuffer.flip();
System.out.println(Charset.defaultCharset().newDecoder().decode(byteBuffer)
.toString());
} finally {
keyIterator.remove();
key.interestOps(SelectionKey.OP_READ);
}
}
}
}
}
} catch (IOException ignored) {
}
}).start();
}
}
相信大部分没有接触过NIO的同学应该会直接跳过代码到这一行:原来使用JDK原生的NIO的API实现一个简单的服务端通信程序是如此复杂!
复杂的我都没耐心解释这一坨代码的执行逻辑,不过我们还是先对照NIO来解释下几个核心思路:
轮询器selector
,在这个例子中 serverSelector
负责轮询是否有新的连接,clientSelector
负责轮询是否有数据可读。clientSelector
上,这样就不用像IO模型中1w个while循环在死等,参见(1)。clientSelector
被一个while死循环包裹着,如果在某一时刻有多个连接有数据可读,那么通过 clientSelector.select(1)
方法可以轮询出来,进而批量处理,参见(2)。其他细节部分,就不再过多说明了,太复杂,你也不用对代码的细节深究。总之,强烈不建议直接使用具有JDK的原生NIO编程来进行网络开发,下面总结下原因:
正因为如此,我客户端代码都懒得给你看0-0。
JDK的NIO犹如带刺的玫瑰,虽然美好,让人向往,但是使用不当会让你抓耳挠腮,痛不欲生,正因为如此,Netty横空出世!
Netty到底是否何方神圣? 用一句话来说就是:Netty封装了JDK的NIO,让你用的更爽,你不用写一大堆复杂的代码了。
用官方正式的话来说就是:Netty是一个异步事件驱动的网络应用框架,用于快速开发可维护的高性能服务端和客户端。
下面是我总结的使用Netty,不使用JDK原生NIO的原因(原生JDK的NIO编程弊端上面说过了,下面我说重点说下Netty带来的好处):
使用Netty实现上面案例:
首先,引入Maven依赖
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.6.Final</version>
</dependency>
然后,下面是服务端实现部分
NettyServer.java
public class NettyServer {
public static void main(String[] args) {
ServerBootstrap serverBootstrap = new ServerBootstrap();
NioEventLoopGroup boos = new NioEventLoopGroup();
NioEventLoopGroup worker = new NioEventLoopGroup();
serverBootstrap
.group(boos, worker)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<NioSocketChannel>() {
protected void initChannel(NioSocketChannel ch) {
ch.pipeline().addLast(new StringDecoder());
ch.pipeline().addLast(new SimpleChannelInboundHandler<String>() {
@Override
protected void channelRead0(ChannelHandlerContext ctx, String msg) {
System.out.println(msg);
}
});
}
})
.bind(8000);
}
}
这么一小段代码就实现了我们前面NIO编程中的所有的功能,包括服务端启动,接受新连接,打印客户端传来的数据,怎么样,是不是比JDK原生的NIO编程优雅许多?
初学Netty的时候,由于大部分人对NIO编程缺乏经验,因此,将Netty里面的概念与IO模型结合起来可能更好理解
然后下面是客户端NIO的实现部分
NettyClient.java
public class NettyClient {
public static void main(String[] args) throws InterruptedException {
Bootstrap bootstrap = new Bootstrap();
NioEventLoopGroup group = new NioEventLoopGroup();
bootstrap.group(group)
.channel(NioSocketChannel.class)
.handler(new ChannelInitializer<Channel>() {
@Override
protected void initChannel(Channel ch) {
ch.pipeline().addLast(new StringEncoder());
}
});
Channel channel = bootstrap.connect("127.0.0.1", 8000).channel();
while (true) {
channel.writeAndFlush(new Date() + ": hello world!");
Thread.sleep(2000);
}
}
}
在客户端程序中,group对应了我们IOClient.java中main函数起的线程,剩下的逻辑我在后面的文章中会详细分析,现在你要做的事情就是把这段代码拷贝到你的IDE里面,然后运行main函数,最后回到NettyServer.java的控制台,你会看到效果。
使用Netty之后是不是觉得整个世界都美好了,一方面Netty对NIO封装得如此完美,写出来的代码非常优雅,另外一方面,使用Netty之后,网络通信这块的性能问题几乎不用操心,尽情地让Netty榨干你的CPU吧。