[Java]-高并发框架Netty简介

Netty是一款异步的事件驱动的网络应用程序框架，支持快速地开发可维护的高性能的面向协议的服务器和客户端。

Netty简介

NIO

NIO(Non Blocking IO)：非阻塞IO；是Java1.4中引入的。提供了SocketChannel和ServerSocketChannel两种不同的套接字通道实现，都支持阻塞和非阻塞两种模式。

NIO通过设定套接字为非阻塞模式（configureBlocking(false)），然后借助Selector选择器来实现。他使用了事件通知API以确定在一组非阻塞套接字中有哪些已就绪能够进行的I/O操作。

多路复用器Selector是Java NIO编程的基础，多路复用器提供选择已经就绪的任务的能力，简单的说，Selector会不断的轮询注册在其上的Channel，如果某个Channel上面有新的TCP连接接入、读和写事件，这个Channel就处于就绪状态，会被Selector轮询出来，然后通过SelectionKey可以获取就绪Channel的集合，进行后续的I/O操作。

Event事件

Netty 使用不同的事件来通知状态的改变或者是操作的状态。事件可能包括：

• 连接已被激活或者连接失活
• 数据读取；
• 用户事件；
• 错误事件。
• 打开或者关闭到远程节点的连接；
• 将数据写到或者冲刷到套接字。

线程模型

Netty 主要基于主从 Reactors 多线程模型做了一定的修改，其中主从 Reactor 多线程模型有多个 Reactor：

• MainReactor 负责客户端的连接请求，并将请求转交给 SubReactor。
• SubReactor 负责相应通道的 IO 读写请求。
• 非IO请求（具体逻辑处理）的任务则会直接写入队列，等待 worker threads 进行处理。

Netty线程模型的基石是建立在EventLoop上的，其采用协同设计用于处理并发和网络。

• 服务端启动时，通常会有两个NioEventLoopGroup：一个是监听线程组，主要是监听客户端请求，另一个是工作线程组，主要是处理与客户端的数据通讯。
• 客户端只有一个NioEventLoopGroup，就是用来处理与服务端通信的线程组。
• NioEventLoopGroup可以理解为一个线程池，内部维护了一组线程，每个线程负责处理多个Channel上的事件，而一个Channel只对应于一个线程，这样可以回避多线程下的数据同步问题。

Pipeline模型

Netty的Pipeline模型用的是责任链设计模式，当boss线程监控到绑定端口上有accept事件：

• 为该socket连接实例化Pipeline，并将InboundHandler和OutboundHandler按序加载到Pipeline中；
• 然后将该socket连接（也就是Channel对象）挂载到selector上。

一个selector对应一个线程，该线程会轮询所有挂载在他身上的socket连接有没有read或write事件，然后通过线程池去执行Pipeline的业务流。selector如何查询哪些socket连接有read或write事件，主要取决于调用操作系统的哪种IO多路复用内核：

• 如果是select（注意，此处的select是指操作系统内核的select IO多路复用，不是Netty的seletor对象），那么将会遍历所有socket连接，依次询问是否有read或write事件，最终操作系统内核将所有IO事件的socket连接返回给Netty进程；当有很多socket连接时，这种方式将会大大降低性能，因为存在大量socket连接的遍历和内核内存的拷贝。
• 如果是epoll，性能将会大幅提升，因为他基于完成端口事件，已经维护好有IO事件的socket连接列表，selector直接取走，无需遍历，也少掉内核内存拷贝带来的性能损耗。

Pipeline的责任链是通过ChannelHandlerContext对象串联的，ChannelHandlerContext对象里封装了ChannelHandler对象，通过prev和next节点实现双向链表。Pipeline的首尾节点分别是head和tail，当selector轮询到socket有read事件时，将会触发Pipeline责任链，从head开始调起第一个InboundHandler的ChannelRead事件，接着通过fire方法依次触发Pipeline上的下一个ChannelHandler。

ChannelHandler分为InbounHandler和OutboundHandler，InboundHandler用来处理接收消息，OutboundHandler用来处理发送消息。head的ChannelHandler既是InboundHandler又是OutboundHandler，无论是read还是write都会经过head，所以head封装了unsafe方法，用来操作socket的read和write。tail的ChannelHandler只是InboundHandler，read的Pipleline处理将会最终到达tail。

零拷贝与ByteBuf

Netty使用多路复用技术，提高处理连接的并发性；通过零拷贝更多提高性能：

• Netty的接收和发送数据采用DIRECT BUFFERS，使用堆外直接内存进行Socket读写，不需要进行字节缓冲区的二次拷贝；
• Netty提供了组合Buffer对象，可以聚合多个ByteBuffer对象进行一次操作；
• Netty的文件传输采用了transferTo方法，它可以直接将文件缓冲区的数据发送到目标Channel，避免了传统通过循环write方式导致的内存拷贝问题；
• 内存池：为了减少堆外直接内存的分配和回收产生的资源损耗问题，Netty提供了基于内存池的缓冲区重用机制；
• 使用主从Reactor多线程模型，提高并发性；
• 采用了串行无锁化设计，在IO线程内部进行串行操作，避免多线程竞争导致的性能下降；

ByteBuf是一个存储字节的容器，最大特点就是使用方便，它既有自己的读索引和写索引，方便对整段字节缓存进行读写；也支持get/set，方便对其中每一个字节进行读写。他有三种模式：

• Heap Buffer 堆缓冲区：是ByteBuf最常用的模式，他将数据存储在堆空间。
• Direct Buffer 直接缓冲区：内存分配都不发生在堆，jvm通过本地方法调用分配内存，这样做有两个好处：
  • 通过免去中间交换的内存拷贝，提升IO处理速度；
  • 直接缓冲区的内容可以驻留在垃圾回收扫描的堆区以外，也就意味着规避了在高负载下频繁的GC过程对应用线程的中断影响。
• Composite Buffer 复合缓冲区：相当于多个不同ByteBuf的视图。

示例

本节给出一个传统NIO服务端，以及使用Netty实现的服务端与客户端聊天程序示例。

Java NIO服务端

通过ServerSocketChannel可以做服务端侦听；为使其非阻塞，需要设定Blocking为false。对于每一个Channel，都注册到Selector，在有事件到达时，会触发。

在遍历事件集合时，对于处理过的元素要移除，避免被再次触发。

public class NioSelectorServer {
    public static void main(String[] args) throws IOException {
        ServerSocketChannel srvChannel = ServerSocketChannel.open();
        srvChannel.socket().bind(new InetSocketAddress(9000));
        srvChannel.configureBlocking(false);

        Selector select = Selector.open();
        SelectionKey selKey = srvChannel.register(select, SelectionKey.OP_ACCEPT);
        System.out.println("Server started at: " + srvChannel.getLocalAddress());

        while (true){
            select.select();

            Set<SelectionKey> setKey = select.selectedKeys();
            for (Iterator<SelectionKey> it=setKey.iterator(); it.hasNext();){
                SelectionKey key = it.next();
                if(key.isAcceptable()){
                    acceptClient(select, key);
                }else if(key.isReadable()) {
                    handleClient(key);
                }

                it.remove();
            }
        }
    }

    private static void acceptClient(Selector select, SelectionKey key) throws IOException {
        ServerSocketChannel srvChannel = (ServerSocketChannel)key.channel();

        SocketChannel socketChannel = srvChannel.accept();
        socketChannel.configureBlocking(false);
        SelectionKey selKey = socketChannel.register(select, SelectionKey.OP_READ);
        System.out.println("Client connected: " + socketChannel.getRemoteAddress());
    }

    private static void handleClient(SelectionKey key) throws IOException {
        SocketChannel socketChannel = (SocketChannel)key.channel();
        ByteBuffer buf = ByteBuffer.allocate(100);
        int nLen = socketChannel.read(buf);
        if(nLen>0){
            System.out.println("Received: " + new String(buf.array()));
        }else if(nLen==-1){ // client closed
            System.out.println("Client closed: " + socketChannel.getRemoteAddress());
            socketChannel.close();
        }
    }
}

Netty服务端

Netty服务端有固定的流程：创建主线程池以及工作线程池，然后设定channel对应类（阻塞、非阻塞，及其他），以及添加channelHandler。

因只收发字符串串，编解码就使用Netty的StringDecoder与StringEncoder即可。

public class ChatServer {
    public static void main(String[] args) {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workGroup = new NioEventLoopGroup(4);
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 100)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast("decoder", new StringDecoder());
                            pipeline.addLast("encoder", new StringEncoder());
                            pipeline.addLast(new ChatServerHandler());
                        }
                    });

            ChannelFuture cf = bootstrap.bind(9001).sync();
            out.println("Server started at: " + cf.channel().localAddress());
            // wait for close
            cf.channel().closeFuture().sync();
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
        out.println("Chat server shutdown");
    }
}

在聊天服务端中，执行继承SimpleChannelInboundHandler即可：

• channelRead0：Simple中最重要的方法，返回指定类型的接收值；
• channelActive：当有连接到来时触发；
• channelInactive：有连接断开时触发；
• channelReadComplete：读取完成时触发（可以在里面做一些Flush等操作）；
• exceptionCaught：有异常时触发，此时可通过ctx.close()关闭连接；

import static java.lang.System.out;

public class ChatServerHandler extends SimpleChannelInboundHandler<String> {
    private static ChannelGroup chGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        Channel ch = ctx.channel();
        chGroup.writeAndFlush("[Client]" + ch.localAddress() + " online " + LocalDateTime.now());
        chGroup.add(ch);
        out.println("Connect from: " + ch.remoteAddress());
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        Channel ch = ctx.channel();
        chGroup.writeAndFlush("[Client]" + ch.localAddress() + " offline " + LocalDateTime.now());
        out.println("Client closed: " + ch.remoteAddress());
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        Channel from = ctx.channel();
        chGroup.forEach(ch -> {
            if (ch == from) {
                ch.writeAndFlush("[Self]: " + msg);
            } else {
                ch.writeAndFlush(from.remoteAddress() + ": " + msg);
            }
        });
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        out.println("read complete");
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        out.println(ctx.channel().remoteAddress() + cause.getMessage());
        ctx.close();
    }
}

Netty客户端

客户端通过Bootstrap初始化线程池，设定ChannelHandler，并发起连接；

通过Scanner获取输入，并发送到服务端。

public class ChatClient {
    public static void main(String[] args) {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer<SocketChannel>() {

                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast("decoder", new StringDecoder());
                            pipeline.addLast("encoder", new StringEncoder());
                            pipeline.addLast(new ChatClientHandler());
                        }
                    });

            ChannelFuture cf = bootstrap.connect("localhost", 9001).sync();
            Channel ch = cf.channel();
            out.println("Connected: " + ch.localAddress() + " -> " + ch.remoteAddress());
            // read/write
            Scanner scan = new Scanner(System.in);
            out.print("Msg to Send: ");
            while (ch.isActive() && scan.hasNext()) {
                String msg = scan.nextLine();
                if ("quit".equals(msg))
                    break;
                ch.writeAndFlush(msg);
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            group.shutdownGracefully();
        }
    }
}

客户端Handler非常简单，只需输出接收到内容，并处理异常即可：

public class ChatClientHandler extends SimpleChannelInboundHandler<String> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        out.println(msg);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        out.println(ctx.channel().remoteAddress() + cause.getMessage());
        ctx.close();
    }
}