Netty深入浅出（无处不在的IO）

为什么要有Netty

Netty是为了解决网络编程的复杂性和提供易于使用、高性能和可扩展的框架而开发的。它通过提供一组可重用的组件来处理网络通信的低级细节，例如套接字管理、线程和缓冲，简化了开发网络应用程序的过程。这使开发人员可以专注于应用程序逻辑而不是网络编程的复杂性。此外，Netty支持各种协议和传输机制，使其成为构建各种网络应用程序的多功能选择。

Java中的IO模型

Netty是一个Java编写的网络IO库，Netty在其底层仍然使用Java I/O库，如java.nio包。它使用了Java NIO（New I/O）的一些特性，例如非阻塞通道（Channel）、选择器（Selector）等，以实现高性能的网络通信。

三种通信模型

  • BIO (Blocking I/O): 同步阻塞I/O模式，数据的读取写入必须阻塞在一个线程内等待其完成。在活动连接数不是特别高（小于单机1000）的情况下，这种模型是比较不错的。线程池本身就是一个天然的漏斗，可以缓冲一些系统处理不了的连接或请求。

  • NIO (New I/O): NIO是一种同步非阻塞的I/O模型，在Java 1.4 中引入了NIO框架。NIO提供了与传统BIO模型中的 Socket 和 ServerSocket 相对应的 SocketChannel 和 ServerSocketChannel 两种不同的套接字通道实现,两种通道都支持阻塞和非阻塞两种模式。阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性都不好；非阻塞模式正好与之相反。

  • AIO (Asynchronous I/O): AIO 也就是 NIO 2。在 Java 7 中引入了 NIO 的改进版 NIO 2,它是异步非阻塞的IO模型。异步 IO 是基于事件和回调机制实现的，也就是应用操作之后会直接返回，不会堵塞在那里，当后台处理完成，操作系统会通知相应的线程进行后续的操作。AIO 是异步IO的缩写，虽然 NIO 在网络操作中，提供了非阻塞的方法，但是 NIO 的 IO 行为还是同步的。对于 NIO 来说，我们的业务线程是在 IO 操作准备好时，得到通知，接着就由这个线程自行进行 IO 操作，IO操作本身是同步的。

NIO

示例代码
  • 服务端
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;public class NIOServer {public static void main(String[] args) throws IOException {// 创建ServerSocketChannelServerSocketChannel serverSocketChannel = ServerSocketChannel.open();serverSocketChannel.socket().bind(new InetSocketAddress(8080));serverSocketChannel.configureBlocking(false); // 设置为非阻塞模式Selector selector = Selector.open();serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);System.out.println("Server is listening on port 8080...");while (true) {int readyChannels = selector.select();if (readyChannels == 0) {continue;}Set<SelectionKey> selectedKeys = selector.selectedKeys();Iterator<SelectionKey> keyIterator = selectedKeys.iterator();while (keyIterator.hasNext()) {SelectionKey key = keyIterator.next();if (key.isAcceptable()) {SocketChannel clientChannel = serverSocketChannel.accept();clientChannel.configureBlocking(false);clientChannel.register(selector, SelectionKey.OP_READ);System.out.println("Accepted connection from " + clientChannel.getRemoteAddress());} else if (key.isReadable()) {SocketChannel clientChannel = (SocketChannel) key.channel();ByteBuffer buffer = ByteBuffer.allocate(1024);int bytesRead = clientChannel.read(buffer);if (bytesRead == -1) {clientChannel.close();System.out.println("Client disconnected.");} else if (bytesRead > 0) {buffer.flip();while (buffer.hasRemaining()) {clientChannel.write(buffer); // 回显客户端发送的数据}buffer.clear();}}keyIterator.remove();}}}
}
  • 客户端
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;public class NIOClient {public static void main(String[] args) throws IOException {SocketChannel socketChannel = SocketChannel.open();socketChannel.connect(new InetSocketAddress("localhost", 8080));String message = "Hello, NIO Server!";ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());socketChannel.write(buffer); // 发送消息给服务器ByteBuffer responseBuffer = ByteBuffer.allocate(1024);int bytesRead = socketChannel.read(responseBuffer); // 读取服务器的响应if (bytesRead != -1) {responseBuffer.flip();byte[] bytes = new byte[responseBuffer.remaining()];responseBuffer.get(bytes);String response = new String(bytes);System.out.println("Received from server: " + response);}socketChannel.close(); // 关闭客户端连接}
}

AIO

示例代码
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousChannelGroup;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.Executors;public class AIOTimeServer {public static void main(String[] args) throws IOException {int port = 8080;AsynchronousChannelGroup group = AsynchronousChannelGroup.withThreadPool(Executors.newFixedThreadPool(10));final AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open(group);serverChannel.bind(new InetSocketAddress(port));System.out.println("Server is listening on port " + port);serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {@Overridepublic void completed(AsynchronousSocketChannel clientChannel, Void attachment) {serverChannel.accept(null, this); // 接受下一个连接String response = "Current time: " + System.currentTimeMillis();ByteBuffer buffer = ByteBuffer.wrap(response.getBytes());clientChannel.write(buffer, null, new CompletionHandler<Integer, Void>() {@Overridepublic void completed(Integer result, Void attachment) {try {clientChannel.close();} catch (IOException e) {e.printStackTrace();}}@Overridepublic void failed(Throwable exc, Void attachment) {exc.printStackTrace();try {clientChannel.close();} catch (IOException e) {e.printStackTrace();}}});}@Overridepublic void failed(Throwable exc, Void attachment) {exc.printStackTrace();}});try {group.awaitTermination(Long.MAX_VALUE, java.util.concurrent.TimeUnit.SECONDS);} catch (InterruptedException e) {e.printStackTrace();}}
}

为什么Netty依旧使用NIO的API？

Netty 不看重 Windows 上的使用，在 Linux 系统上，AIO 的底层实现仍使用 EPOLL（后续会讲），没有很好实现 AIO，因此在性能上没有明显的优势，而且被 JDK 封装了一层不容易深度优化。

Linux的IO模型

Java的I/O模型是在Java编程语言层面的抽象，而Linux的I/O模型是操作系统内核层面的实现。因此，虽然它们有一些相似之处，但并不是完全相同的概念。

LINUX五种IO模型

同步和异步：同步和异步是针对应用程序和内核的交互而言的，同步指的是用户进程触发IO 操作并等待或者轮询的去查看IO 操作是否就绪，而异步是指用户进程触发IO 操作以后便开始做自己的事情，而当IO 操作已经完成的时候会得到IO 完成的通知。

阻塞和非阻塞：阻塞和非阻塞是针对于进程在访问数据的时候，根据IO操作的就绪状态来采取的不同方式，说白了是一种读取或者写入操作方法的实现方式，阻塞方式下读取或者写入函数将一直等待，而非阻塞方式下，读取或者写入方法会立即返回一个状态值。

  1. 阻塞式IO

  2. 非阻塞式IO

  3. IO多路复用

  4. 信号驱动

  5. 异步IO

前面四种IO模型实际上都属于同步IO，只有最后一种是真正的异步IO，因为无论是多路复用IO还是信号驱动模型，IO操作的第2个阶段都会引起用户线程阻塞，也就是内核进行数据拷贝的过程都会让用户线程阻塞。

从图中可以看出用户态与内核态的切换，那么什么是用户/内核态呢？这也是下面的内容。

用户态与内核态

I/O（Input/Output，输入/输出）和用户态与内核态之间存在密切的关系，特别是在操作系统中。用户态和内核态是操作系统中的两个不同特权级别，它们用于管理和保护计算机系统的资源。以下是关于I/O、用户态和内核态之间的关系的重要信息：

  1. I/O操作涉及用户态和内核态：

    • I/O操作包括从应用程序到外部设备（如磁盘、网络、键盘、显示器等）的数据传输。这些操作通常涉及到用户态和内核态之间的切换。
    • 当应用程序需要执行I/O操作时，它会调用操作系统提供的I/O系统调用（例如，读取文件或发送数据包）。这些系统调用是在用户态执行的。
    • 操作系统内核负责管理系统资源和I/O设备，因此在执行I/O操作时，控制必须从用户态切换到内核态，以便内核可以直接访问硬件资源。

  2. 用户态和内核态的切换：

    • 用户态和内核态是不同的CPU执行模式。在用户态下，应用程序只能访问有限的资源，而在内核态下，操作系统内核可以访问系统的全部资源。
    • 当应用程序需要执行需要特权访问的操作，例如执行系统调用或访问设备驱动程序，它必须通过软中断或异常将控制权切换到内核态。这个切换是由操作系统的内核来处理的。
    • 用户态到内核态的切换会涉及一些开销，因为需要保存和恢复CPU寄存器、切换堆栈等操作。因此，频繁的切换会影响性能。

  3. 内核态的I/O处理：

    • 一旦控制切换到内核态，操作系统内核就可以执行I/O操作。它会管理设备驱动程序、缓冲区、中断处理等细节，以确保数据的正确传输。
    • 内核还会维护I/O请求队列，以有效地处理多个I/O请求。

  4. 异步I/O和用户态I/O：

    • 异步I/O是一种I/O模型，允许应用程序继续执行其他任务，而不必等待I/O操作完成。在这种情况下，通常使用异步I/O库来管理I/O操作，而不需要频繁地切换用户态和内核态。
    • 异步I/O通常通过回调函数或事件通知机制来处理I/O完成事件。

I/O操作涉及用户态和内核态之间的切换，因为操作系统内核必须管理和控制I/O设备。这个切换是操作系统的核心功能之一，用于确保计算机系统的稳定性、安全性和性能。不同的I/O模型可以影响用户态和内核态之间的切换方式和频率。说到内核态切换，下面不得不介绍的就是零拷贝。

Zero Copy（零拷贝）

Netty与零拷贝（Zero-Copy）之间有密切的关系，因为Netty是一个网络应用框架，专门设计用于高性能的网络通信，而零拷贝是一项技术，可以用于提高数据传输的效率，特别是在网络通信中。

以下是Netty与零拷贝的关系和如何在Netty中利用零拷贝技术的一些重要信息：

Netty的高性能特性：Netty被设计为高性能的网络应用框架，它旨在处理大量并发连接和高吞吐量的网络通信。为了实现这一目标，Netty采用了多种性能优化技术，其中之一就是零拷贝。

零拷贝是一种优化技术，旨在减少数据在内存之间的复制次数。传统的数据传输通常涉及将数据从一个缓冲区复制到另一个缓冲区，这会引入额外的CPU和内存开销。零拷贝技术通过操作系统或硬件支持，允许数据在不复制的情况下从一个地方传输到另一个地方，从而提高了数据传输的效率。
   
`ByteBuf`是Netty的自定义缓冲区类型，它支持零拷贝和引用计数等特性。在Netty中，`ByteBuf`可以在数据传输时直接暴露底层数据，而不需要进行数据复制，从而减少了CPU和内存开销。

零拷贝的实现

传统IO

read：将数据从磁盘通过DMA读取到内核缓存区中，在拷贝到用户缓冲区

write: 先将数据写入到socket缓冲区中，经过DMA写入网卡设备

在这里插入图片描述

4次切换，4次拷贝

虚拟内存 mmap

1.虚拟内存空间可以远远大于物理内存空间
2.多个虚拟内存可以指向同一个物理地址


正是多个虚拟内存可以指向同一个物理地址，可以把内核空间和用户空间的虚拟地址映射到同一个物理地址，这样的话，就可以减少IO的数据拷贝次数。用户态可以直接访问内核态的数据。

4次切换，3次拷贝

sendFile

sendfile表示在两个文件描述符之间传输数据，它是在操作系统内核中操作的，避免了数据从内核缓冲区和用户缓冲区之间的拷贝操作。

在这里插入图片描述

2次切换，3次拷贝

sendfile + DMA scatter/gather实现的零拷贝

linux2.4版本后，对sendfile做了优化升级，引入SG-DMA技术，其实就是对DMA拷贝加入了scatter/gather操作，它可以直接从内核空间缓冲区中将数据读取到网卡，这样的话还可以省去CPU拷贝。

在这里插入图片描述

2次切换，2次拷贝，CPU全程不参与数据搬运

直接内存 Direct ByteBuf

Netty通常使用直接内存（Direct Memory）来提高性能。直接内存是一种特殊的内存分配方式，不同于Java堆内存。

  1. ByteBuf与直接内存：Netty中的ByteBuf是一个用于处理字节数据的缓冲区抽象。ByteBuf可以使用直接内存分配，这称为"Direct ByteBuf"。直接内存分配意味着ByteBuf中的数据存储在堆外内存，而不是在Java堆中。

  2. 减少内存复制：在进行网络数据传输时，数据通常需要从应用程序的缓冲区复制到操作系统内核缓冲区，然后再从内核缓冲区复制到网络适配器。使用直接内存，可以在这些步骤中减少或消除数据复制，提高了性能。

  3. 零拷贝：直接内存可以与零拷贝相结合，使数据可以在应用程序和操作系统之间进行高效的传输。

  4. 缓冲区池：Netty通常使用池化的ByteBuf来管理直接内存的分配和释放。这种方式可以避免频繁地分配和释放直接内存，提高了内存管理的效率。

  5. 内存管理控制：Netty提供了一些工具和机制，帮助开发者有效地管理直接内存，包括手动释放、自动回收等。

示例代码
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;public class NettyDirectMemoryExample {public static void main(String[] args) throws InterruptedException {// 创建两个EventLoopGroup，一个用于接受客户端连接，一个用于处理客户端请求NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);NioEventLoopGroup workerGroup = new NioEventLoopGroup();try {// 创建ServerBootstrapServerBootstrap serverBootstrap = new ServerBootstrap();serverBootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).childHandler(new ChannelInitializer<SocketChannel>() {@Overrideprotected void initChannel(SocketChannel ch) {ch.pipeline().addLast(new EchoServerHandler());}});// 绑定端口并启动服务器serverBootstrap.bind(8080).sync().channel().closeFuture().sync();} finally {bossGroup.shutdownGracefully();workerGroup.shutdownGracefully();}}// 自定义ChannelHandler处理客户端消息static class EchoServerHandler extends ChannelInboundHandlerAdapter {@Overridepublic void channelRead(ChannelHandlerContext ctx, Object msg) {ByteBuf in = (ByteBuf) msg;ByteBuf out = Unpooled.directBuffer(); // 创建Direct ByteBuftry {out.writeBytes(in); // 将接收到的数据写入Direct ByteBufctx.write(out); // 写入回应数据到客户端ctx.flush();} finally {in.release(); // 释放接收缓冲区out.release(); // 释放Direct ByteBuf}}@Overridepublic void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {cause.printStackTrace();ctx.close();}}
}

使用直接内存需要谨慎管理，以避免内存泄漏和其他问题。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/129444.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Dubbo 环境隔离

Dubbo 环境隔离

通过标签实现流量隔离环境&#xff08;灰度、多套开发环境等&#xff09; 无论是在日常开发测试环境&#xff0c;还是在预发生产环境&#xff0c;我们经常都会遇到流量隔离环境的需求。 在日常开发中&#xff0c;为了避免开发测试过程中互相干扰&#xff0c;我们有搭建多套独…
阅读更多...
Flink---11、状态管理（按键分区状态（值状态、列表状态、Map状态、归约状态、聚合状态）算子状态（列表状态、广播状态））

Flink---11、状态管理（按键分区状态（值状态、列表状态、Map状态、归约状态、聚合状态）算子状态（列表状态、广播状态））

星光下的赶路人star的个人主页 这世上唯一扛得住岁月摧残的就是才华 文章目录 1、状态管理1.1 Flink中的状态1.1.1 概述1.1.2 状态的分类 1.2 按键分区状态&#xff08;Keyed State&#xff09;1.2.1 值状态&#xff08;ValueState&#xff09;1.2.2 列表状态&#xff08;ListS…
阅读更多...
在Remix中编写你的第一份智能合约

在Remix中编写你的第一份智能合约

智能合约简单来讲就是&#xff1a;部署在去中心化区块链上的一个合约或者一组指令&#xff0c;当这个合约或者这组指令被部署以后&#xff0c;它就不能被改变了&#xff0c;并会自动执行&#xff0c;每个人都可以看到合约里面的条款。更深层次的理解就是&#xff1a;这些代码会…
阅读更多...
王道考研计算机组成原理——计算机硬件的基础知识

王道考研计算机组成原理——计算机硬件的基础知识

计算机组成原理的基本概念 计算机硬件的针脚都是用来传递信息&#xff0c;传递数据用的&#xff1a; 服务程序包含一些调试程序&#xff1a; 计算机硬件的基本组成 控制器通过电信号来协调其他部件的工作&#xff0c;同时负责解析存储器里存放的程序指令&#xff0c;然后指挥…
阅读更多...
vue3 组件v-model绑定props里的值，修改组件的值要触发回调

vue3 组件v-model绑定props里的值，修改组件的值要触发回调

很早之前就写了&#xff0c;一直没写篇博客记录下 <select v-model"typeVal" />const emit defineEmits([update:type]); const props defineProps({type: { type: String, default: }, });const typeVal computed({get() {return props.type;},set(value…
阅读更多...
Vue-1.8生命周期

Vue-1.8生命周期

Vue生命周期 一个Vue实例从创建到销毁的整个过程。 生命周期&#xff1a; 1&#xff09;创建&#xff1a;响应式数据 ->发送初始化渲染请求 2&#xff09;挂载&#xff1a;渲染数据->操作dom 3&#xff09;更新&#xff1a;数据修改&#xff0c;更新视图 4&#xf…
阅读更多...
基于SpringBoot的桂林旅游景点导游平台

基于SpringBoot的桂林旅游景点导游平台

目录 前言 一、技术栈 二、系统功能介绍 用户信息管理 景点类型管理 景点信息管理 线路推荐管理 用户注册 线路推荐 论坛交流 三、核心代码 1、登录模块 2、文件上传模块 3、代码封装 前言 随着信息技术在管理上越来越深入而广泛的应用&#xff0c;管理信息系统的实…
阅读更多...
一篇短小精悍的文章让你彻底明白KMP算法中next数组的原理

一篇短小精悍的文章让你彻底明白KMP算法中next数组的原理

以后保持每日一更&#xff0c;由于兴趣较多&#xff0c;更新内容不限于数据结构&#xff0c;计算机组成原理&#xff0c;数论&#xff0c;拓扑学......&#xff0c;所谓&#xff1a;深度围绕职业发展&#xff0c;广度围绕兴趣爱好。往下看今日内容 一.什么是KMP算法 KMP&#x…
阅读更多...
SpringCloudGateway网关整合swagger3+Knife4j3，basePath丢失请求404问题

SpringCloudGateway网关整合swagger3+Knife4j3，basePath丢失请求404问题

在集成 Spring Cloud Gateway 网关的时候&#xff0c;会出现没有 basePath 的情况&#xff0c;例如定义的 /jeeplus-auth、/jeeplus-system 等微服务前缀导致访问接口404&#xff1a; maven依赖&#xff1a; swagger2于17年停止维护&#xff0c;现在最新的版本为 Swagger3&am…
阅读更多...
学习开发一个RISC-V上的操作系统（汪辰老师） — unrecognized opcode `csrr t0,mhartid‘报错问题

学习开发一个RISC-V上的操作系统（汪辰老师） — unrecognized opcode `csrr t0,mhartid‘报错问题

前言 &#xff08;1&#xff09;此系列文章是跟着汪辰老师的RISC-V课程所记录的学习笔记。 &#xff08;2&#xff09;该课程相关代码gitee链接&#xff1b; &#xff08;3&#xff09;PLCT实验室实习生长期招聘&#xff1a;招聘信息链接 正文 &#xff08;1&#xff09;在跟着…
阅读更多...
ntlm哈希传递

ntlm哈希传递

哈希传递就是ntlm哈希 概念 早期SMB协议铭⽂在⽹络上传输数据&#xff0c;后来诞⽣了LM验证机制&#xff0c;LM机制由于过于简 单&#xff0c;微软提出了WindowsNT挑战/响应机制&#xff0c;这就是NTLM LM NTLM 哈希传递攻击是针对相同密码的用户认证直接发起攻击&#xff0c…
阅读更多...
Opengl之立方体贴图

Opengl之立方体贴图

简单来说，立方体贴图就是一个包含了6个2D纹理的纹理，每个2D纹理都组成了立方体的一个面：一个有纹理的立方体。你可能会奇怪，这样一个立方体有什么用途呢？为什么要把6张纹理合并到一张纹理中，而不是直接使用6个单独的纹理呢？立方体贴图有一个非常有用的特性，它可以通过一…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023