Netty入门教程——认识Netty

BIO的处理流程

NIO的处理流程

除了BIO和NIO之外，还有一些其他的IO模型，下面这张图就表示了五种IO模型的处理流程：

五种常见的IO模型

• BIO，同步阻塞IO，阻塞整个步骤，如果连接少，他的延迟是最低的，因为一个线程只处理一个连接，适用于少连接且延迟低的场景，比如说数据库连接。

• NIO，同步非阻塞IO，阻塞业务处理但不阻塞数据接收，适用于高并发且处理简单的场景，比如聊天软件。

• 多路复用IO，他的两个步骤处理是分开的，也就是说，一个连接可能他的数据接收是线程a完成的，数据处理是线程b完成的，他比BIO能处理更多请求。

• 信号驱动IO，这种IO模型主要用在嵌入式开发，不参与讨论。

• 异步IO，他的数据请求和数据处理都是异步的，数据请求一次返回一次，适用于长连接的业务场景。

以上摘自Linux IO模式及 select、poll、epoll详解

Netty为什么传输快

Netty的传输快其实也是依赖了NIO的一个特性——零拷贝。我们知道，Java的内存有堆内存、栈内存和字符串常量池等等，其中堆内存是占用内存空间最大的一块，也是Java对象存放的地方，一般我们的数据如果需要从IO读取到堆内存，中间需要经过Socket缓冲区，也就是说一个数据会被拷贝两次才能到达他的的终点，如果数据量大，就会造成不必要的资源浪费。 Netty针对这种情况，使用了NIO中的另一大特性——零拷贝，当他需要接收数据的时候，他会在堆内存之外开辟一块内存，数据就直接从IO读到了那块内存中去，在netty里面通过ByteBuf可以直接对这些数据进行直接操作，从而加快了传输速度。 下两图就介绍了两种拷贝方式的区别，摘自Linux 中的零拷贝技术，第 1 部分

传统数据拷贝

零拷贝

上文介绍的ByteBuf是Netty的一个重要概念，他是netty数据处理的容器，也是Netty封装好的一个重要体现，将在下一部分做详细介绍。

为什么说Netty封装好？

要说Netty为什么封装好，这种用文字是说不清的，直接上代码：

• 阻塞I/O

public class PlainOioServer {

public void serve(int port) throws IOException {

final ServerSocket socket = new ServerSocket(port); //1

try {

for (;😉 {

final Socket clientSocket = socket.accept(); //2

System.out.println("Accepted connection from " + clientSocket);

new Thread(new Runnable() { //3

@Override

public void run() {

OutputStream out;

try {

out = clientSocket.getOutputStream();

out.write(“Hi!\r\n”.getBytes(Charset.forName(“UTF-8”))); //4

out.flush();

clientSocket.close(); //5

} catch (IOException e) {

e.printStackTrace();

try {

clientSocket.close();

} catch (IOException ex) {

// ignore on close

}

}

}

}).start(); //6

}

} catch (IOException e) {

e.printStackTrace();

}

}

}

• 非阻塞IO

public class PlainNioServer {

public void serve(int port) throws IOException {

ServerSocketChannel serverChannel = ServerSocketChannel.open();

serverChannel.configureBlocking(false);

ServerSocket ss = serverChannel.socket();

InetSocketAddress address = new InetSocketAddress(port);

ss.bind(address); //1

Selector selector = Selector.open(); //2

serverChannel.register(selector, SelectionKey.OP_ACCEPT); //3

final ByteBuffer msg = ByteBuffer.wrap(“Hi!\r\n”.getBytes());

for (;😉 {

try {

selector.select(); //4

} catch (IOException ex) {

ex.printStackTrace();

// handle exception

break;

}

Set readyKeys = selector.selectedKeys(); //5

Iterator iterator = readyKeys.iterator();

while (iterator.hasNext()) {

SelectionKey key = iterator.next();

iterator.remove();

try {

if (key.isAcceptable()) { //6

ServerSocketChannel server =

(ServerSocketChannel)key.channel();

SocketChannel client = server.accept();

client.configureBlocking(false);

client.register(selector, SelectionKey.OP_WRITE |

SelectionKey.OP_READ, msg.duplicate()); //7

System.out.println(

"Accepted connection from " + client);

}

if (key.isWritable()) { //8

SocketChannel client =

(SocketChannel)key.channel();

ByteBuffer buffer =

(ByteBuffer)key.attachment();

while (buffer.hasRemaining()) {

if (client.write(buffer) == 0) { //9

break;

}

}

client.close(); //10

}

} catch (IOException ex) {

key.cancel();

try {

key.channel().close();

} catch (IOException cex) {

// 在关闭时忽略

}

}

}

}

}

}

• Netty

public class NettyOioServer {

public void server(int port) throws Exception {

final ByteBuf buf = Unpooled.unreleasableBuffer(

Unpooled.copiedBuffer(“Hi!\r\n”, Charset.forName(“UTF-8”)));

EventLoopGroup group = new OioEventLoopGroup();

try {

ServerBootstrap b = new ServerBootstrap(); //1

b.group(group) //2

.channel(OioServerSocketChannel.class)

.localAddress(new InetSocketAddress(port))

.childHandler(new ChannelInitializer() {//3

@Override

public void initChannel(SocketChannel ch)

throws Exception {

ch.pipeline().addLast(new ChannelInboundHandlerAdapter() { //4

@Override

public void channelActive(ChannelHandlerContext ctx) throws Exception {

ctx.writeAndFlush(buf.duplicate()).addListener(ChannelFutureListener.CLOSE);//5

}

});

}

});

ChannelFuture f = b.bind().sync(); //6