[ Java | NIO详解 | 4/5 ] 网络编程

最新推荐文章于 2024-11-04 22:26:34 发布
最新推荐文章于 2024-11-04 22:26:34 发布
阅读量399 收藏
点赞数 2
分类专栏： JavaSE 文章标签： java 网络 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51026595/article/details/121295998
版权

通用Client

     public static void main(String[] args) throws IOException {
         SocketChannel channel = SocketChannel.open(new InetSocketAddress(25565));
         // 注：Buffer大小最好为有效数据大小 -> 防止服务端解码异常
         channel.write(ByteBuffer.wrap("传输的信息".getBytes(StandardCharsets.UTF_8)));
         channel.close();
     }

阻塞模式

Server

     private static final ByteBuffer BUFFER = ByteBuffer.allocate(1024);
 ​
     public static void main(String[] args) throws IOException {
         ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
         serverSocketChannel.bind(new InetSocketAddress(25565));
         while (true) {
             SocketChannel socketChannel = serverSocketChannel.accept(); // 阻塞在此处
             socketChannel.read(BUFFER);
             BUFFER.flip();
             System.out.println(StandardCharsets.UTF_8.decode(BUFFER));
             BUFFER.clear();
         }
     }

非阻塞模式

Server - 轮询

     public static void main(String[] args) throws IOException {
         ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
         serverSocketChannel.configureBlocking(false); // 非阻塞模式
         serverSocketChannel.bind(new InetSocketAddress(25565));
         List<SocketChannel> channels = new ArrayList<>();
         while (true) {
             SocketChannel socketChannel = serverSocketChannel.accept();
             if (socketChannel != null) { // 连接建立
                 socketChannel.configureBlocking(false); // 非阻塞模式
                 channels.add(socketChannel);
             }
             for (SocketChannel channel : channels) {
                 ByteBuffer BUFFER = ByteBuffer.allocate(1024);
                 int read = channel.read(BUFFER); // 非阻塞模式
                 if (read > 0) {
                     BUFFER.flip();
                     System.out.println(StandardCharsets.UTF_8.decode(BUFFER));
                     BUFFER.clear();
                 }
             }
         }
     }

Server - Selector

注意 每注册一个 SocketChannel 都会多出一个 SelectionKey。我们调用 remove() 仅是从 selectedKeys 集合中移除本次调用到的 key ( Selector 自己不会移除），防止下次 select() 时集合中仍存有先前处理过的 key。 key 的 OP_ACCEPT 状态处理完成后就被迭代器 remove()，而 OP_READ 状态在套接字连接的过程中一直存在，故每次 select() 时 selectedKeys 中都会加入正在进行传输的 SocketChanne l ! ! ! 在保证数据读完且客户端连接断开的情况下（ read() == -1 ）可以通过 cancel() 永久移除该 key，否则默认数据传输未完成，在每个下一次轮询时重新加入该key，耗时耗力!

     public static void main(String[] args) throws IOException {
         // 1. 创建 Selector 管理多个 Channel
         Selector selector = Selector.open();
         ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
         serverSocketChannel.configureBlocking(false); // 非阻塞模式
         // 2. 建立 Selector 和 Channel 的联系（注册）
         serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
         serverSocketChannel.bind(new InetSocketAddress(25565));
         while (true) {
             // 3. 查询事件，若存在则加入到 selectedKeys
             selector.select();
             // 4. 处理事件，selectedKeys 内包含所有发生的事件
             Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
             while (iterator.hasNext()) {
                 SelectionKey key = iterator.next();
                 // 处理 key 时要手动从 selectedKeys 集合中删除，否则下次获取时 key 上无对应 Channel 调用会空指针
                 iterator.remove();
                 if (key.isAcceptable()) { // 是否是 Accept 事件
                     // 向对应端口的 ServerSocketChannel 注册 OP_READ 监听
                     ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
                     SocketChannel socketChannel = serverChannel.accept();
                     socketChannel.configureBlocking(false);
                     socketChannel.register(selector, SelectionKey.OP_READ);
                 } else if (key.isReadable()) {
                     try {
                         System.out.println(key);
                         SocketChannel channel = (SocketChannel) key.channel();
                         ByteBuffer buffer = ByteBuffer.allocate(32);
                         int length;
                         while ((length = channel.read(buffer)) > 0) {
                             buffer.flip();
                             System.out.println(new String(buffer.array(), 0, length));
                             buffer.clear();
                         }
                         // -1 : 客户端断开
                         if (length == -1) key.cancel();
                     } catch (IOException e) {
                         log.warn("客户端断开连接: ", e);
                         key.cancel();
                     }
                 }
             }
         }
     }

消息边界

当 数据长度 > 缓存区大小 时，数据会分开发送导致服务端解码异常，称为消息边界问题

可能出现的问题

  • 黏包 - 多个消息合并在同一 Buffer 中发出

  • 半包 - 由于 Buffer 大小限制，消息被分割发出

解决方案

  • 固定 Buffer 长度

    多用于传输固定范围内长度的数据，服务端固定一个 Buffer 大小 >= 消息长度，客户端发送消息时未达到最大长度则补齐进行发送。（浪费带宽）

  • 分隔符

    在两消息间加入特定分隔符，服务端接受时逐行比对进行消息分割接收，可能存在 Buffer 扩容问题。（效率低）

  • TLV 格式

    TLV - Type、Length、Value。规定数个字节的头文件长度记录消息长度，服务端基于此可有效进行消息接收。类似 Http 式。（ Buffer 需要提前分配，若过大影响服务端吞吐量）

ByteBuffer大小分配

  • 每个 Channel 都需要记录可能被切分的消息，因为 ByteBuffer 不能被多个 Channel 共同使用，因此需要为每个 Channel 维护一个独立的 ByteBuffer

  • ByteBuffer 不能太大，比如一个 ByteBuffer 1Mb 的话，要支持百万连接就要 1Tb 内存，因此需要设计大小可变的 ByteBuffer

    • 一种思路是首先分配一个较小的 buffer，例如 4k，如果发现数据不够，再分配 8k 的 buffer，将4k buffer 内容拷贝至 8k buffer，优点是消息连续容易处理，缺点是数据拷贝耗费性能，参考实现

    • 另一种思路是用多个数组组成 buffer，一个数组不够，把多出来的内容写入新的数组，与前面的区别是消息存储不连续解析复杂，优点是避免了拷贝引起的性能损耗

多线程优化

多核 Worker 分配 SocketChannel

     public static void main(String[] args) throws IOException {
         Thread.currentThread().setName("Boss");
         ServerSocketChannel ssc = ServerSocketChannel.open();
         ssc.bind(new InetSocketAddress(25565));
         ssc.configureBlocking(false);
 ​
         Selector selector = Selector.open();
         ssc.register(selector, SelectionKey.OP_ACCEPT);
 ​
         Worker[] workers = new Worker[Runtime.getRuntime().availableProcessors()];
         for (int i = 0; i < workers.length; ++ i) {
             workers[i] = new Worker("worker-" + i);
         }
         AtomicInteger integer = new AtomicInteger();
         while (true) {
             selector.select();
             Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
             while (iterator.hasNext()) {
                 SelectionKey key = iterator.next();
                 iterator.remove();
                 if (key.isAcceptable()) {
                     SocketChannel sc = ssc.accept();
                     log.debug("connect {}", sc);
                     sc.configureBlocking(false);
 ​
                     workers[integer.getAndIncrement() % workers.length].register(sc);
                 }
             }
         }
     }
 ​
     /**
      * Worker 的实际意义就是
      *      对于每个工作线程都新建一个 Selector 对 SocketChannel
      *    进行拆分管理，每个连接被均匀分配到每个工作线程上。
      * */
     private static class Worker implements Runnable {
         private final String name;
         private Thread thread;
         private Selector selector;
 ​
         public Worker(String name) {
             this.name = name;
         }
         
         public void register(SocketChannel sc) throws IOException {
             if (thread == null) {
                 thread = new Thread(this, name);
                 selector = Selector.open();
                 thread.start();
             }
             // 唤醒 Worker 线程执行注册操作，在下一次循环中进行 select() 筛选事件监听
             selector.wakeup();
             SelectionKey register = sc.register(selector, SelectionKey.OP_READ);
             log.debug("register {}", register);
         }
         
         @Override
         public void run() {
             while (true) {
                 try {
                     // Selector#select() 会阻塞，故使用队列延迟执行 SocketChannel 注册
                     selector.select();
                     Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
                     while (iterator.hasNext()) {
                         SelectionKey key = iterator.next();
                         iterator.remove();
                         if (key.isReadable()) {
                             log.debug("read...");
                             ByteBuffer buffer = ByteBuffer.allocate(16);
                             SocketChannel sc = (SocketChannel) key.channel();
                             sc.read(buffer);
                             buffer.flip();
                             System.out.println(Charset.defaultCharset().decode(buffer));
                         }
                     }
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
     }

如何拿到 cpu 个数

  • Runtime.getRuntime().availableProcessors() 如果工作在 docker 容器下，因为容器不是物理隔离的，会拿到物理 cpu 个数，而不是容器申请时的个数

  • 这个问题直到 jdk 10 才修复，使用 jvm 参数 UseContainerSupport 配置，默认开启

IllTamer
关注
专栏目录
网络编程，select多路复用的具体使用，监听accept、read、write事件，解决客户端断开，消息边界问题
qq_44027353的博客
11-13 1844
Selector selector就是管理多个channel的，并且能够管理监测这些channel上有没有事件发生，如果有事件发生，selector就能获得这些事件，我们的线程再去处理这些事件。没有事件发生的时候线程可以阻塞。 事件有四种： accept 客户端发起了连接请求时触发该类型的事件 connect 客户端与服务器连接建立成功就会触发该事件 read 可读事件 write 可写事件 使用Selector步骤 创建Selector 创
Java网络编程IO模型 --- BIO、NIO、AIO详解
2301_82242988的博客
04-29 726
金三银四马上就到了，希望大家能好好学习一下这些技术点学习视频：大厂面试真题：金三银四马上就到了，希望大家能好好学习一下这些技术点学习视频：[外链图片转存中…(img-3ST7KdL7-1714389491204)]大厂面试真题：[外链图片转存中…(img-wIJZpwVt-1714389491205)]本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录。
Java NIO学习8(Selector 补充版ServerSocketChannel）
Anders 的专栏(Talk is cheap, show me the code！)
01-27 7764
大部分是javanio书上的内容 我来整理一番，外加一些解释，着色！ ServerSocketChannel 让我们从最简单的ServerSocketChannel来开始对socket通道类的讨论 ServerSocketChannel是一个基于通道的socket监听器。它同我们所熟悉的java.net.ServerSocket执行相同的基本任务，不过它增加了通道语义，因此能够在非阻塞模
【Java.NIO】Selector，及SelectionKey
热门推荐
王晓斌的专栏
12-07 2万+
java.nio.channels public abstract class Selector extends Object implements Closeable Selector(选择器)是Java NIO中能够检测一到多个NIO通道，并能够知晓通道是否为诸如读写事件做好准备的组件。这样，一个单独的线程可以管理多个channel，从而管理多个网络连接。 使用Select
SelectionKey
a429080578的博客
06-28 772
SelectionKey 1：selectionKey.channel()方法返回的 channel是ServerSocketChannel还是SocketChannel是由前边注册这个key时是注册channel确定的。 2：基本处理流程 服务器端先注册接收Key serverSocketChannel.register(selector,SelectionKey.OP_ACCE...
Java NIO2详解：异步文件和网络编程
哎 你看的博客
06-30 1033
一、NIO2 简介 从NIO到NIO2： 发展历程及优势 异步IO模型： 原理和优势 核心组件： AsynchronousChannel, CompletionHandler, AsynchronousFileChannel, AsynchronousSocketChannel/AsynchronousServerSocketChannel 二、异步文件编程 AsynchronousFileChannel： 打开、读取、写入文件 CompletionHandler： 处理异步操作结果
Java网络编程和NIO详解开篇：Java网络编程基础
Java技术江湖
07-13 8570
老曹眼中的网络编程基础 转自：https://mp.weixin.qq.com/s/XXMz5uAFSsPdg38bth2jAA 我们是幸运的，因为我们拥有网络。网络是一个神奇的东西，它改变了你和我的生活方式，改变了整个世界。 然而，网络的无标度和小世界特性使得它又是复杂的，无所不在，无所不能，以致于我们无法区分甚至无法描述。 对于一个码农而言，了解网络的基础知识可能还是从...
Java中的NIO编程详解
微赚淘客开发者博客
07-03 408
NIO（New I/O）是Java提供的一种非阻塞的IO（输入输出）操作方式，引入了Channel、Buffer和Selector等新概念，相较于传统的IO操作更为高效和灵活。传统的IO模型是阻塞式的，每个连接都需要独立的线程来处理，而NIO模型使用单线程管理多个连接，通过Selector实现了非阻塞IO，提升了系统的性能和吞吐量。通过NIO可以实现高效的事件驱动的网络编程。Selector是NIO编程的核心组件之一，它提供了一种可以检测多个通道上事件的机制，从而使一个单独的线程可以管理多个通道。
Java NIO 快速入门：Java 非阻塞 IO 编程详解
m0_64516972的博客
07-17 1605
Java NIO（New Input/Output）是一套从Java 1.4开始引入的高效IO库，旨在替代传统的阻塞式IO。它通过非阻塞模式和多路复用技术，极大地提升了并发性能，非常适合高并发场景。本文将以简单易懂的方式带你入门Java NIO，轻松掌握其核心概念和实际应用。
详解Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码）
08-28
Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码） Java 网络IO编程是 Java 编程语言中最重要的知识点之一，涉及到网络编程的各种技术和模型。本篇文章主要介绍了 Java 网络IO编程总结，包括 BIO、NIO 和 AIO ...
Java网络编程详解与实战案例
10-10
内容概要：本文介绍了Java网络编程的基础，包括TCP/IP协议和UDP协议的理解与使用。通过示例演示了如何使用Socket和ServerSocket建立基本的网络通信方式，涵盖了基于TCP的阻塞I/O、非阻塞I/O以及UDP广播/多播的内容。...
HashMap为什么线程不安全？
rnnf_yyds的博客
11-03 559
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
[自用，更新自day5]瑞吉外卖代码及笔记
lapiii的博客
11-01 1055
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
spring循环依赖解决方式
qq_36400213的博客
11-04 700
字段注入和setter注入则提供了更多的灵活性，但需要更谨慎地管理对象的状态。方法注入和注解注入则适用于特定的场景。在Spring框架中，依赖注入（Dependency Injection，DI）是一种实现控制反转（Inversion of Control，IoC）的机制，用于将对象的依赖关系自动注入到对象中。这种方式不如构造器注入严格，但比字段注入更灵活，因为它可以在不创建新实例的情况下改变对象的依赖。这种方式是推荐的，因为它可以保证对象在创建时就处于完全初始化的状态，并且可以使得bean不可变。
SpringSession源码分析
lkr_lkr的博客
11-01 417
默认对常规Session的理解和使用，如何使用Set-Cookie。
【Java知识】Java基础-对象排序的实现
最新发布
wendao76的专栏
11-04 222
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
JavaScript的第十一天
全栈学习ing
10-31 775
在使用offset系列时需注意该属性为css属性，一般用于和javascript结合使用来获取信息，所以在使用该属性时只能获取值而不能改变值。最近的具有定位属性的祖先元素顶部边缘左侧边缘。
Java学习Day54：初遇萍萍(权限控制)
weixin_51721783的博客
10-29 1300
web.xml：在health_backend工程的web.xml文件中配置用于整合Spring Security框架的过滤器DelegatingFilterProxy。
Java NIO详解：改变I/O的游戏规则
"Java NIO (中文版)" 是一本关于Java Non-blocking Input/...通过学习这些内容，开发者可以构建高性能、低延迟的网络应用程序和服务，特别适合于高并发的服务器端编程场景，如聊天服务器、游戏服务器或大数据处理系统。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值