NIO 与 Netty

最新推荐文章于 2023-06-04 19:22:54 发布
最新推荐文章于 2023-06-04 19:22:54 发布
阅读量1.1k 收藏 4
点赞数 1
文章标签： java netty epoll socket nio
原文链接：https://juejin.cn/post/6956516753752981535
版权

NIO

什么是 NIO

NIO全称Non Blocking IO，同步非阻塞IO框架。服务器实现模式为一个线程可以处理多个请求(连接)，客户端发送的连接请求都会注册到多路复用器selector上，多路复用器轮询到连接有IO请求就进行处理

为什么用 NIO

常见的网络服务中，如果每一个客户端都维持一个与登陆服务器的连接。那么服务器将维护多个和客户端的连接以出来和客户端的contnect 、read、write ，特别是对于长链接的服务，有多少个c端，就需要在s端维护同等的IO连接。这对服务器来说是一个很大的开销(著名的C10K问题)

NIO 怎么玩

Reactor模式的单线程版-NIO服务端

public static void main(String[] args) throws IOException {
    ServerSocketChannel socketChannel = ServerSocketChannel.open();
    // 绑定端口
    socketChannel.bind(new InetSocketAddress(8080));
    // 声明异步
    socketChannel.configureBlocking(false);
    // 声明多路复用器，创建 linux下的epoll文件描述对象
    Selector selector = Selector.open();
    // 注册连接事件
    socketChannel.register(selector,SelectionKey.OP_ACCEPT);
    while (true){
        // 通过操作系统的epoll，选择触发事件的selectionKey 加入set集合中
        selector.select();
        final Set<SelectionKey> selectionKeys = selector.selectedKeys();
        final Iterator<SelectionKey> iterator = selectionKeys.iterator();
        // 遍历触发事件的selectionKey，selectionKey中包含 socketChannel
        while (iterator.hasNext()){
            final SelectionKey next = iterator.next();
            // 判断事件类型
            if(next.isAcceptable()){
                // 如果是连接事件，给对应的SocketChannel注册读取事件
                final ServerSocketChannel channel = (ServerSocketChannel) next.channel();
                final SocketChannel accept = channel.accept();
                accept.configureBlocking(false);
                accept.register(selector,SelectionKey.OP_READ);
            }else if (next.isReadable()){
                // 如果是读取事件，直接读取
                final SocketChannel channel = (SocketChannel) next.channel();
                ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                final int read = channel.read(byteBuffer);
                System.out.println(new String(byteBuffer.array(),0,read));
            }
        }
        // 移除set集合中已经处理的socketChannel，避免二次处理
        iterator.remove();
    }
}
复制代码

如何运行并测试，该NIO服务端呢？

Windows 环境下，可以通过命令行工具的 telnet 命令，连接服务端并发送数据；
telnet localhost 8080 连接服务端
ctrl+] 打开发送页面，并通过 send 命令发送消息到服务端

image.png

NIO 是如何接受socket请求并读取数据？

在NIO服务端启动时，会通过Selector selector = Selector.open()创建一个linux epoll/windows select实例对象，然后再selector.select()时，将事件、channel注册到epoll中并等待事件发生，如果事件发生会从操作系统内部的就绪事件列表中rdList【当操作系统感知到事件发生时，会将事件加入到就绪事件列表中rdList】，选择对应的事件加入到SelectionKey中，然后进行处理。

NIO解决了BIO什么痛点，还有什么缺陷

  • NIO 解决了
    • BIO 线程阻塞，读写阻塞，线程等待时间过长问题
    • 客户端连接数过多导致的服务端CPU过高，线程浪费过多问题（C10K）
  • NIO 还有以下缺陷
    • 没有从本质上解决C10K问题【如果存在10万连接，同时读写数据，单selector，NIO的循环也需要很久】
    • selector.select()，存在空轮询bug，当select()方法没有获取事件，也有可能不阻塞，直接向下执行，且一次出现后续会一直出现。
    • 代码编写复杂，需要大量异常IO处理

Netty

Netty 是基于NIO的，运用Reactor模型设计的高性能、异步事件驱动的网络应用框架。

Netty 解决了 NIO 的哪些痛点

  • 解决了selector.select()的 空轮询bug
  • 简化了开发，netty内部已经对断线重连、 网络闪断、心跳处理、半包读写、 网络拥塞和异常流等进行了处理。
  • netty内部初始化多个selector，从而避免C10K问题

Netty 怎么玩

Netty 服务端

public class NettyService {
    public static int port = 8080;
    public static void main(String[] args) {
        // 创建接受accept事件的selector线程组
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        // 创建处理read/write等业务处理事件的selector线程组
        EventLoopGroup workerGroup = new NioEventLoopGroup(8);
        ServerBootstrap bootstrap = new ServerBootstrap();
        bootstrap.group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        // 业务处理handler
                        socketChannel.pipeline().addLast(new DefaultChannelInboundHandlerAdapter());
                    }
                })
                .option(ChannelOption.SO_BACKLOG, 128)
                .childOption(ChannelOption.SO_KEEPALIVE, true);
        try {
            ChannelFuture future = bootstrap.bind(port).sync();
            future.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
}
复制代码

服务端业务处理handler

public class DefaultChannelInboundHandlerAdapter extends ChannelInboundHandlerAdapter {
    protected static ChannelGroup channels = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
    @Override
    public void channelRegistered(ChannelHandlerContext ctx) throws Exception {
        System.out.println("客户端上线："+ ctx.channel().remoteAddress());
        channels.add(ctx.channel());
    }

    @Override
    public void channelUnregistered(ChannelHandlerContext ctx) throws Exception {
        System.out.println("客户端下线："+ ctx.channel().remoteAddress());
        channels.remove(ctx.channel());
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf byteBuf = (ByteBuf) msg;
        String rtn = "客户端："+ ctx.channel().remoteAddress()+":"+ byteBuf.toString(CharsetUtil.UTF_8);
        channels.forEach(channel -> channel.writeAndFlush(Unpooled.wrappedBuffer(rtn.getBytes(StandardCharsets.UTF_8))));
    }
}
复制代码

Netty 客户端

public class NettyClient {
    public static void main(String[] args) {
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(workerGroup)
                .channel(NioSocketChannel.class)
                .option(ChannelOption.SO_KEEPALIVE, true)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    public void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new StringEncoder()).addLast(new StringDecoder())
                                .addLast(new DefaultClientHandlerAdapter());
                    }
                });
        try {
            ChannelFuture connect = bootstrap.connect("127.0.0.1", 8080).sync();
            Channel channel = connect.channel();
            System.out.println("===="+channel.localAddress()+"====");
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNext()){
                String next = scanner.next();
                channel.writeAndFlush(next);
            }
            channel.closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            workerGroup.shutdownGracefully();
        }
    }
}
复制代码

客户端业务处理handler

public class DefaultClientHandlerAdapter extends ChannelInboundHandlerAdapter{
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println("客户端接受到消息");
        System.out.println(msg.toString());
    }

    @Override
    public void channelWritabilityChanged(ChannelHandlerContext ctx) throws Exception {
        System.out.println("客户端写入消息");
    }
}
复制代码

如何运行并测试，以上netty代码

先运行服务段main方法，然后运行客户端main方法
就可以通过客户端控制台输入内容发送到服务端

Netty 的线程模型

在网上看到一张图片，感觉非常到位！（服务端）

image.png

  • 根据 new NioEventLoopGroup() 的源码，不难发现NioEventLoopGroup其实是一个线程组对象，内部的线程池对象包含 selector 和 taskQueue;
  • bossGroup 负责accept事件，workerGroup负责读写事件
  • NioEventLoop 其实是一个线程
  • pipeline 是处理事件的业务管道
  • ChannelHandler 是业务管道中的具体的处理类，以客户端应用程序为例，如果事件的运动方向是从客户端到服务端的，那么我们称这些事件为出站的，即客户端发送给服务端的数据会通过pipeline中的一系列ChannelOutboundHandler(ChannelOutboundHandler调用是从tail到head方向逐个调用每个handler的逻辑)，并被这些Handler处理，反之则称为入站的，入站只调用pipeline里的ChannelInboundHandler逻辑(ChannelInboundHandler调用是从head到tail方向逐个调用每个handler的逻辑)。

image.png

Netty 粘包拆包

TCP 做为传输层协议，并不理解上层业务数据的具体含义，它只会根据TCP 缓冲区的大小，进行数据包的划分。比如缓存区的大小是10k，你发送了12k的数据，TCP会将这个12K数据，拆分成10K+2K【拆包】，先发送10k，然后等下一个数据，取8K与上一个数据的2K组成10K【粘包】再发送。

Netty 如何解决

  1. 消息定长度，传输的消息大小固定长度，如，每次发送100字节，不足的补空字符
  2. 每次消息末尾添加特殊字符，然后再消息接受端进行分割
  3. 发送消息的同时发送长度，先发送长度，然后再发送消息。消息接收端，接受到消息长度，然后等待下一个数据包到达，获取指定长度。

Netty提供了多个解码器，可以进行分包的操作，如下：

  • LineBasedFrameDecoder （回车换行分包）
  • DelimiterBasedFrameDecoder（特殊分隔符分包）
  • FixedLengthFrameDecoder（固定长度报文来分包）

Netty 断线自动重连实现

在客户端实现再客户端连接服务端时，添加监听器，监听连接状态，如果连接失败，再次重连
代码实现：

ChannelFuture cf = bootstrap.connect(host, port);
cf.addListener(new ChannelFutureListener() {
    @Override
    public void operationComplete(ChannelFuture future) throws Exception {
        if (!future.isSuccess()) {
            //重连交给后端线程执行
            future.channel().eventLoop().schedule(() -> {
                try {
                    connect();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }, 3000, TimeUnit.MILLISECONDS);
        }
    }
});
//对通道关闭进行监听
cf.channel().closeFuture().sync();
复制代码

Netty 怎么解决 selector.select() 的空轮询 bug

Netty 创建了一个int selectCnt = 0，在执行select时，selectCnt+1，如果select获取到的事件数量大于0时，selectCnt 设置为 0，当selectCnt大于设置的阈值512【io.netty.selectorAutoRebuildThreshold 可以自己设置】时，Netty会新建一个selector，并将出现bug的selector上的注册事件重新注册到新建的selector上，同时关闭出bug的selector。

源码：

    protected void run() {
        int selectCnt = 0;
        for (;;) {
            try {
                int strategy;
                try {
                    strategy = selectStrategy.calculateStrategy(selectNowSupplier, hasTasks());
                    switch (strategy) {
                    case SelectStrategy.CONTINUE:
                        continue;
                    case SelectStrategy.BUSY_WAIT:
                    case SelectStrategy.SELECT:
                        // 省略部分为select的一些获取逻辑
                    default:
                    }
                } catch (IOException e) {
                    rebuildSelector0();
                    selectCnt = 0;
                    handleLoopException(e);
                    continue;
                }
                selectCnt++;
                cancelledKeys = 0;
                needsToSelectAgain = false;
                final int ioRatio = this.ioRatio;
                boolean ranTasks;
				// 省略部分不相干代码
                if (ranTasks || strategy > 0) {
                    if (selectCnt > MIN_PREMATURE_SELECTOR_RETURNS && logger.isDebugEnabled()) {
                        logger.debug("Selector.select() returned prematurely {} times in a row for Selector {}.",
                                selectCnt - 1, selector);
                    }
                    selectCnt = 0;
                } else if (unexpectedSelectorWakeup(selectCnt)) { // 这行代码是关键！
                    selectCnt = 0;
                }
            } catch (CancelledKeyException e) {
                // Harmless exception - log anyway
                if (logger.isDebugEnabled()) {
                    logger.debug(CancelledKeyException.class.getSimpleName() + " raised by a Selector {} - JDK bug?",
                            selector, e);
                }
            } catch (Error e) {
				// 省略异常处理代码
            }
        }
    }
复制代码

unexpectedSelectorWakeup方法：

private static final int SELECTOR_AUTO_REBUILD_THRESHOLD 
        = SystemPropertyUtil.getInt("io.netty.selectorAutoRebuildThreshold", 512);

private boolean unexpectedSelectorWakeup(int selectCnt) {
    if (Thread.interrupted()) {
        return true;
    }
    if (SELECTOR_AUTO_REBUILD_THRESHOLD > 0 &&
            selectCnt >= SELECTOR_AUTO_REBUILD_THRESHOLD) {
        rebuildSelector();
        return true;
    }
    return false;
}


作者：疯狂小周
链接：https://juejin.cn/post/6956516753752981535
来源：掘金
 

Java秦心
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java高并发编程代码（Netty NIO 实例）
05-12
Java高并发编程代码（Netty NIO 实例）
Netty（一）
qq_34800986的博客
12-27 221
Netty介绍 Netty是由JBOSS提供的一个java开源框架，现为Github上独立的项目。 一个异步事件驱动的网络应用程序框架，用于快速开发高性能、高可靠性的IO网络框架。 Netty主要针对在TCP协议下，面向Clients端的高并发应用，或者Peer-to-Peer场景下的大量数据传输的应用 Netty本质是一个NIO框架，适用于服务器通讯的相关业务场景 Netty 的应用场景 ...
Netty与NIO
qq_30118563的博客
05-12 5200
Linux的 网络IO 一、简介 1、Linux上所有外部设备都抽象为file。 2、对一个文件的读写会调用kernel命令，返回file descriptor (fd)； 3、对一个socket的读写会调用kernel命令，返回socketfd 4、描述符实际就是一个数字，指向内核中一个结构体（文件路径、数据区等一些属性） 二、Linux 对Socket IO模型的抽象 ...
NIO 与 Netty 编程
u014069688的博客
08-16 367
BIO 编程 BIO 有的称之为 basic(基本) IO,有的称之为 block(阻塞) IO， 主要应用于文件 IO 和网络 IO，这里不再说文件 IO, 大家对此都非常熟悉， 本次课程主要讲解网络 IO。 在 JDK1.4 之前， 我们建立网络连接的时候只能采用 BIO， 需要先在服务端启动一个ServerSocket， 然后在客户端启动 Socket 来对服务端进行通信， 默认情况下服务端...
netty系列之:NIO和netty详解
程序那些事
03-09 5631
文章目录简介NIO常用用法NIO和EventLoopGroupNioEventLoopGroupSelectorProviderSelectStrategyFactoryRejectedExecutionHandlerEventLoopTaskQueueFactoryNioEventLoop总结 简介 netty为什么快呢？这是因为netty底层使用了JAVA的NIO技术，并在其基础上进行了性能的优化，虽然netty不是单纯的JAVA nio，但是netty的底层还是基于的是nio技术。 nio是JDK1.
深入Hotspot源码与Linux内核理解NIO与Netty线程模型.pdf
03-14
深入Hotspot源码与Linux内核理解NIO与Netty线程模型
详细介绍 NIO与Netty编程-实战讲义详细pdf.7z
03-09
NIO与Netty编程-课程讲义，包含 BIO、NIO、Io的介绍，NIO网络聊天的案列，自定义RPC的实现与设计
深入Hotspot源码与Linux内核理解NIO与Netty线程模型.rar
最新发布
03-20
深入Hotspot源码与Linux内核理解NIO与Netty线程模型 源码讲解分析，非常详细，简单易懂
Java NIO框架Netty简单使用的示例
08-28
本篇文章主要介绍了Java NIO框架Netty简单使用的示例,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
NIO+Netty5视频教程与Netty源码剖析视频教程
11-20
视频分两部分：第一部分：深入浅出Netty源码剖析；第二部分：NIO+Netty5各种RPC架构实战演练（非加密）
什么是NIO，什么是Netty
islautao的博客
06-04 709
本文简单介绍了NIO和Netty的概念、特点和区别，并给出了一些示例和插图。希望对你有所帮助。
NIO与Netty入门
脚踏实地
01-29 226
NIO与IO的比较： IO NIO 面向流 面向缓冲 阻塞IO 非阻塞IO 阻塞IO： 查看读取数据是否就绪、没就绪就一直等待、单向、只能读或写 非阻塞IO： 没有就绪就返回标志、就绪拷贝到用户线程、以块的方式处理 什么是NIO: non-blocking IO(实际上是 new io) ...
java网络编程—NIO与Netty(一)
张硕的博客
07-30 2112
接下来一周，系统的总结NIO、IO、以及主流通信框架Netty等相关知识： java网络编程—NIO与Netty(四) java网络编程—NIO与Netty(三) java网络编程—NIO与Netty(二) java网络编程—NIO与Netty(一)对阻塞与非阻塞,同步与异步的理解 同步和异步关注的是消息通信机制 同步：发出一个调用时，等待直到，调用结果的完成后返回。
异步非阻塞框架 netty 与 nio
ws - 兮的博客空间
09-23 1184
第一次深入了解nio，都会感觉非常的难理解阻塞与非阻塞，同步和异步阻塞，非阻塞，下面来看看吧 一、nio 和 netty 是什么? 1、Java NIO(New IO)是一个可以替代标准Java IO API的IO API（从Java 1.4开始) 2、 Netty 是一个基于 JAVA NIO 类库的异步通信框架，它的架构特点是：异步非阻塞、基于事件驱动、高性能、高可靠性和高可定制性。 3、主要...
NIO与netty原理
weixin_45566322的博客
08-30 501
计算机组成原理 App是无法直接操作驱动等内核程序的，需要调用内核程序时，必须向内核进行系统调用。 系统调用与函数调用不是同一个东西。 由于保护模式的存在，我们的程序是无法直接函数调用内核程序，而是通过系统调用。 系统调用，本质就是通过中断执行。 程序中断的过程： 程序中，仿佛函数调用似的调用内核程序，（本质上会产生中断） 系统调用产生中断，中断将内核程序的中断向量（0~255）存入CPU的寄存器 CPU同时会开启一个守护线程，守护我们的程序，以将中断的结果返回 CPU根据中断向量，在
netty+nio
weixin_38446891的博客
07-02 926
netty是什么 面试官：介绍一下自己对 Netty 的认识吧！小伙子。 我：好的！那我就简单用 3 点来概括一下 Netty 吧！ Netty 是一个 基于 NIO 的 client-server(客户端服务器)框架，使用它可以快速简单地开发网络应用程序。 它极大地简化并优化了 TCP 和 UDP 套接字服务器等网络编程,并且性能以及安全性等很多方面甚至都要更好。 支持多种协议 如 FTP，SMTP，HTTP 以及各种二进制和基于文本的传统协议。 用官方的总结就是：Netty 成功地找到了一种在不妥协
NIO和Netty
10年IT大头兵
05-17 84
BIO 阻塞式 流 数组 NIO 非阻塞式 Channel Buffer 1.4之后 文件IO 缓冲区 Buffer 非阻塞的好处，一个线程就可以应付多个客户端， 核心API 4个 Selector选择器 SelectionKey 注册关系 ServerSocketChannel SocketChannel 网络io通道 ...
nio与netty
Young_____Hu的博客
11-22 146
IO分为三种 BIO(传统IO) 同步阻塞IO NIO同步非阻塞IO AIO异步非阻塞IO（涉及linux网络底层，太难，这里不讨论） 阻塞和非阻塞区别： 传统IO是阻塞的，因为read(),write()方法就是阻塞的，此时必须等读完了或者写完了才能进行后面的操作。NIO是非阻塞的，才用多路复用技术，把read()和write()单独给了一个线程，由操作系统完成，所以操作系统读完了或者写完了...
io 错误: socket read timed out_网络编程IO、NIO与Netty
06-02
3. 通过使用非阻塞IO（NIO）或使用Netty等网络编程框架来提高程序的性能和可靠性。 4. 在读取数据时使用缓冲区，减少数据传输过程中的延迟，提高效率。 总之，网络编程中出现的IO错误需要仔细排查问题，找到根本...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值