NIO学习

最新推荐文章于 2025-05-08 22:08:07 发布
最新推荐文章于 2025-05-08 22:08:07 发布
阅读量302 收藏
点赞数
分类专栏： java se 文章标签： socket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_41786712/article/details/106205888
版权
本文深入探讨了Java NIO（非阻塞I/O）的概念，介绍了与BIO的区别以及NIO的重要组件：Channel、Buffer和Selector。通过一个案例展示了NIO如何在多个连接中实现非阻塞的读写操作，揭示了NIO的效率优势和底层的epoll()函数、零拷贝等优化机制。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

4.NIO

4.1 NIO的概念

NIO是NO Blocking IO的缩写，它的交互方式是同步非阻塞的方式。

4.2 BIO的特点

程序的IO操作的完成的状态是一致的，即便某个连接的读写动作未完成(如数据未准备就绪)，也不会阻塞其它连接的读写动作。相对BIO而言，NIO具有效率高，但由于频繁的切换线程上下文，会影响CPU性能的特点。

4.3 NIO的重要组件

Channel(通道)、Buffer(缓冲区)、Selector(多路复用器)是NIO的三元素，也是最重要的组件。实现原理，它只需两个线程就能实现，一个线程将Selector注册到Channel上，另一个线程让Selector去监听并处理它感兴趣的激活连接事件。

4.4 NIO的特点展示和底层原理

NIO特点：
程序的IO操作的完成的状态是一致的，即便某个连接的读写动作未完成，也不会阻塞其它连接的读写动作。

案例：
1.IO模式是NIO模式，
2.服务器端不关闭不停接收客户端的数据，并返回接收结果给客户端
3.ClientA不关闭不断发送数据给服务端，ClientB和ClientC发送一句话给服务端。

// 服务端程序
/**
    NIO三要素
        1.Channel(通道),
        2.Buffer(缓冲区),
        3.Selector(多路复用器).

    实现原理：
        一个线程将Selector注册到Channel上，一个线程让Selector管理连接事件
 */
public class NIOServer implements Runnable {
    private Selector selector;
    private ServerSocketChannel serverChannel;

    // 一个线程将Selector注册到Channel上
    public NIOServer(int port) {
        try {
            serverChannel = ServerSocketChannel.open();
            serverChannel.bind(new InetSocketAddress(port));
            serverChannel.configureBlocking(false);
            selector = Selector.open();
            serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 一个线程让Selector管理连接事件
    public void run() {
        try {
            int count = 0;
            while (true) {
                selector.select();
                Iterator<SelectionKey> keys = selector.selectedKeys().iterator();
                while (keys.hasNext()) {
                    SelectionKey key = keys.next();
                    keys.remove();
                    if (key.isAcceptable()) {
                        handlerAccept();
                    } else if (key.isReadable()) {
                        handlerReaderAndWriter(key);
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void handlerAccept() {
        try {
            SocketChannel channel = serverChannel.accept();
            channel.configureBlocking(false);
            channel.register(selector, SelectionKey.OP_READ);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void handlerReaderAndWriter(SelectionKey key) {
        try {
            SocketChannel channel = (SocketChannel) key.channel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int len;
            if ((len = channel.read(buffer)) != -1) {
                buffer.flip();
                byte[] bytes = new byte[buffer.remaining()];
                buffer.get(bytes);
                System.out.println("客户端" + channel.getRemoteAddress() + "说：" + new String(bytes, 0 , len));
                buffer.clear();
                buffer.put(("服务器端成功接收信息.").getBytes());
                buffer.flip();
                channel.write(buffer);
                buffer.clear();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// 客户端A
public class ClientA {
    public static void main(String[] args) {
        try {
            SocketChannel channel = SocketChannel.open();
            channel.connect(new InetSocketAddress("127.0.0.1", 10000));
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            Scanner sc = new Scanner(System.in);
            while (true) {
                buffer.put(sc.nextLine().getBytes());
                buffer.flip();
                channel.write(buffer);
                buffer.clear();
                int len = channel.read(buffer);
                buffer.flip();
                byte[] bytes = new byte[buffer.remaining()];
                buffer.get(bytes);
                System.out.println(new String(bytes, 0 , len));
                buffer.clear();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// 客户端B
public class ClientB {
    public static void main(String[] args) {
        try {
            SocketChannel channel = SocketChannel.open();
            channel.connect(new InetSocketAddress("127.0.0.1", 10000));
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.put("我是ClientB，Server你好。".getBytes());
            buffer.flip();
            channel.write(buffer);
            buffer.clear();
            int len = channel.read(buffer);
            buffer.flip();
            byte[] bytes = new byte[buffer.remaining()];
            buffer.get(bytes);
            System.out.println(new String(bytes, 0 , len));
            channel.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// 客户端C
public class ClientC {
    public static void main(String[] args) {
        try {
            SocketChannel channel = SocketChannel.open();
            channel.connect(new InetSocketAddress("127.0.0.1", 10000));
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.put("Hello,nice to meet you, I am ClientC。".getBytes());
            buffer.flip();
            channel.write(buffer);
            buffer.clear();
            int len = channel.read(buffer);
            buffer.flip();
            byte[] bytes = new byte[buffer.remaining()];
            buffer.get(bytes);
            System.out.println(new String(bytes, 0 , len));
            channel.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

// 测试类
public class NIODemo {
    public static void main(String[] args) {
        new Thread(new NIOServer(10000)).start();
    }
}

在这里插入图片描述

可以看到，数据读和写成功，各连接事件的状态是一致的，而且博主是先启动ClientA，再启动ClientB和ClientC，在ClientA程序未通过键盘录入数据，显然ClientA数据未准备好，服务端已经收到了ClientB和ClientC的数据，所以NIO是即便某个连接的读写动作未完成(如数据未准备就绪)，也不会阻塞其它连接的读写动作。

NIO的特点是由底层原理决定的，如图：

在这里插入图片描述

和BIO一样，每个客户端的数据一开始先来到的终端的网卡里，当程序调用select()，启动多路复用器将连接事件交由其管理，这时会触发内核中的epoll()函数，**网卡中的所有连接的读写事件的数据会以链表的形式，一次性拷贝到内存中的特定区域，**当Selector轮询到连接事件，便会触发内核中的recvFrom(NOBlocking…)函数，将数据从特点区域零拷贝到用户空间，零拷贝是epoll()的优化功能，拷贝的是数据的地址值。

对比BIO阻塞IO，它是一个接着一个拷贝到内存的，所以一旦某个连接阻塞，全部连接均会阻塞。

如刚才的案例，启动ClientA程序，键盘未输入数据时，ClientA的数据就会阻塞在读事件，但由于Selector的轮询机制，各个客户端的数据已经提前拷贝到内存中，所以不会影响其它连接的数据已就绪的读写事件。

NIO图文详解
qq_40439628的博客
07-12 2884
（1）阻塞I/O模型：阶段一和阶段二用户进程都处于阻塞状态，效率最低，适用于并发量低的小型网站，是java BIO的基础；（2）非阻塞I/O模型：阶段一用户进程处于非阻塞状态，但应用进程需不断轮询内核空间数据是否准备好，消耗大量CPU时间；阶段二用户进程处于非阻塞状态；（3）I/O复用模型：阶段一和阶段二用户进程都处于阻塞状态，但以较少的代价同时监听多个文件描述符，效率较高，适用于并发高的大中型网站，java NIO是实现I/O复用模型的基础；
学习NIO
jiaoyajieqianyi的博客
11-15 209
https://blog.youkuaiyun.com/linsongbin1/article/details/54865371 实例：https://blog.youkuaiyun.com/yhl_jxy/article/details/79335692 netty实例：https://blog.youkuaiyun.com/javadhh/article/details/66477423 https://mp.weixin...
java高级——NIO解读，全网最全最详细，没有之一
最新发布
蓝桉
05-08 1068
本文详细介绍了Java NIO（非阻塞I/O）的核心概念、组件及其工作方式。NIO通过引入通道（Channel）、缓冲区（Buffer）和选择器（Selector）等组件，解决了传统阻塞I/O在高并发场景下的资源浪费和性能瓶颈问题。通道支持双向数据传输和非阻塞模式，缓冲区用于存储数据，选择器则通过多路复用和事件驱动机制高效管理多个通道的I/O操作。文章还分析了NIO的学习难点，包括概念复杂、API繁多、非阻塞编程模型、底层实现复杂等，并提供了学习建议，如结合博客和视频进行学习。通过本文，读者可以系统掌握NI
NIO学习（一）
wcx_csdn的博客
01-21 465
JDK1.6及之前只能用   NIO(1.4后才有)，BIO JDK1.7开始之后有   AIO(NIO 2.0) 1.先理解几个概念：同步，异步，阻塞，非阻塞 ###同步：用户进程触发IO操作并等待或者轮询的去查看IO操作是否就绪；自己上街买衣服，自己亲自干这件事，别的事干不了。  ###异步：用户进程触发IO操作以后便开始做自己的事情，而当IO操作已经完成的时候会得到IO完成的通知
nio学习
huihuishou_su的博客
05-17 188
Nio
NIO学习总结
04-02
《NIO学习总结》 NIO（Non-blocking I/O，非阻塞I/O）是Java在JDK 1.4引入的一种新的I/O模型，它为Java提供了更高效的数据处理方式，尤其适用于高并发、大数据量的网络应用。相较于传统的BIO（Blocking I/O）模型，...
NIO学习-Java源代码分享(含netty)
10-22
在"**NIO学习-Java源代码分享**"这个压缩包中，可能包含了关于NIO的示例代码，包括使用NIO进行文件操作、网络通信的实例，也可能包含Netty或Mina的部分源码，这些都可以作为学习和研究NIO技术的宝贵资源。...
JAVA NIO学习网站
08-05
在《JAVA NIO学习网站》的博文中，作者可能详细讲解了如何使用这些组件以及它们之间的交互。例如，可能会介绍如何创建并配置通道，如何使用缓冲区读写数据，如何注册通道到选择器，以及如何利用选择器处理多个并发...
nio 学习
sprita1的专栏
01-27 969
io与nio区别： io是面向流的，  nio是面向缓冲区的(速度快) io是线程阻塞的，nio是线程非阻塞的，所以在nio中一个单独的线程可以处理多个输入和输出通道（channel）的操作 服务端： selector： channel_1(key的属性为accept) —— 对应 socket_1 循环遍历key建立与客户端连接 >-返回key channe
NIO学习教程
Andrew_Yuan的博客
05-07 3329
文件传输传统的IO通信：磁盘→系统→程序→socket→协议引擎NIO：磁盘→系统→socket→协议引擎NIO注意几个关键词：Java NIO: Channels and Buffers（通道和缓冲区）、Non-blocking IO（非阻塞IO）、Selectors（选择器）。标准的IO基于字节流和字符流进行操作的，而NIO是基于通道（Channel）和缓冲区（Buffer）进行操作，数据总是...
NIO的学习
~忆缘的博客
09-29 291
NIO 什么是NIO IO回顾 IO：Input OutPut（输入 输出） IO技术的作用：解决设备和设备之间的数据传输问题 IO的应用场景：图片上传、下载、打印机打印信息表、解析XML… 概念 即 Java New IO 是1个全新的、 JDK 1.4后提供的 IO API Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO 作用 NIO和IO有相同的作用和目的，但实现方式不同 可替代 标准Java IO 的IO API IO是以流的方式处理数据，而NI
NIO基础的学习
weixin_41168868的博客
11-29 245
nio的概述: NIO 主要有三大核心部分：Channel(通道)，Buffer(缓冲区), Selector(选择器)。传统的 BIO 基于字节流和字符流进行操作，而 NIO 基于 Channel(通道)和 Buffer(缓冲区)进行操作，数据 总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector(选择区)用于监听多个通 道的事件（比如：连接请求，数据到达等），因此使用单个线程...
NIO 基础学习
weixin_53142722的博客
05-24 2271
NIO三大组件：Channel，Selector，ByteBuffer；使用Files提供的方法 进行文件的拷贝，遍历目录文件；非阻塞 vs 阻塞的区别，多路复用的概念； NIO vs BIO的区别； NIO的零拷贝，IO 模型，网络编程......
NIO学习指南：提升Java I/O性能的关键技术
NIO学习总结涵盖了多个关键主题，从核心概念到具体实现细节。 1. **核心概念及基本读写**: - NIO的核心在于其非阻塞I/O模型，与旧的阻塞I/O模型相比，NIO允许并发处理多个I/O请求，提高了性能。它通过`Channel`和`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值