java的IO之NIO

最新推荐文章于 2024-04-26 16:58:27 发布
最新推荐文章于 2024-04-26 16:58:27 发布
阅读量847 收藏 29
点赞数 15
分类专栏： # java基础 文章标签： java nio python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45922256/article/details/136965651
版权

NIO是一种同步非阻塞的I/O模型，在Java 1.4中引入了NIO框架，对应java.nio包，提供了channel、selector、buffer等。
NIO中的N可以理解为Non-blocking不在单纯是New，它支持面向缓冲的，基于通道的I/O操作方法。NIO提供了与传统BIO模型中的Socket和ServerSocket相对应的SocketChannel和ServerSocketChannel，两种不同的套接字通道实现两种通道都支持阻塞和非阻塞式的两种模式，阻塞模式使用就像传统中的支持一样，比较简单，但是性能和可靠性不好；非阻塞模式刚好相反，对于低负载的、低并发的应用程序，可以使用同步阻塞I/O来提高开发效率和维护性；对于高负载的、高并发的应用，应该使用NIO的非阻塞模式来开发。

NIO

NIO（Non-blocking I/O）是Java中的一种非阻塞式IO模型，它基于缓冲区（Buffer）和通道（Channel）的概念，提供了更高效的IO操作和更好的并发处理能力。NIO模型使用单个线程处理多个IO操作，通过选择器（Selector）来管理多个通道，实现非阻塞的IO操作。

NIO的相关概念和使用方式：

  • 通道（Channel）：通道是NIO模型中的基本组件，用于读取和写入数据。通道提供了高效的数据传输能力，并且可以通过非阻塞方式进行IO操作。常见的通道类有FileChannel、SocketChannel和ServerSocketChannel等。

  • 缓冲区（Buffer）：缓冲区是NIO模型中用于存储数据的对象。数据从通道读取到缓冲区，或从缓冲区写入到通道。缓冲区提供了对数据的高效访问和操作。常见的缓冲区类有ByteBuffer、CharBuffer和ByteBuffer等。

  • 选择器（Selector）：选择器是NIO模型中的关键组件，用于管理多个通道的IO操作。通过选择器，可以将一个线程管理多个通道，实现非阻塞的IO操作。选择器会不断地轮询注册在其上的通道，发现有IO事件发生时进行处理。

  • 使用方式：

    1. 创建通道：通过Channel类的工厂方法创建通道对象，如FileChannel.open()、SocketChannel.open()等。
    2. 创建缓冲区：通过Buffer类的静态方法创建缓冲区对象，如ByteBuffer.allocate()、CharBuffer.allocate()等。
    3. 注册通道：将通道注册到选择器上，通过SelectableChannel.register()方法实现。
    4. 选择就绪通道：通过选择器的select()方法选择就绪的通道，进行相应的IO操作。
    5. 处理IO事件：根据不同的IO事件类型，进行读取、写入或其他操作。
    6. 关闭通道：在完成IO操作后，及时关闭通道，释放资源。

BIO模式的操作

BIO 以流的方式处理数据，面向流的 BIO 一次处理一个字节数据：一个输入流产生一个字节数据，一个输出流消费一个字节数据。为流式数据创建过滤器非常容易，链接几个过滤器，以便每个过滤器只负责复杂处理机制的一部分。不利的一面是，面向流的 I/O 通常相当慢。
请添加图片描述

NIO模式的操作

NIO 以块的方式处理数据，面向块的 NIO 一次处理一个数据块，按块处理数据比按流处理数据要快得多。但是面向块的 NIO 缺少一些面向流的 BIO 所具有的优雅性和简单性。
请添加图片描述

解决的问题：

NIO可以用来解决传统的阻塞IO模型中的一些问题，包括：

  • 高并发处理能力：NIO模型使用单个线程处理多个IO操作，通过选择器（Selector）管理多个通道，实现非阻塞的IO操作。这样可以提高系统的并发处理能力，减少线程数量和资源消耗。
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

public class HighConcurrencyServer {
    public static void main(String[] args) {
        try {
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.bind(new InetSocketAddress(8080));
            serverSocketChannel.configureBlocking(false);

            Selector selector = Selector.open();
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

            while (true) {
                selector.select();

                Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();
                while (keyIterator.hasNext()) {
                    SelectionKey key = keyIterator.next();

                    if (key.isAcceptable()) {
                        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
                        SocketChannel clientChannel = serverChannel.accept();
                        clientChannel.configureBlocking(false);
                        clientChannel.register(selector, SelectionKey.OP_READ);
                    } else if (key.isReadable()) {
                        SocketChannel clientChannel = (SocketChannel) key.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        clientChannel.read(buffer);
                        buffer.flip();
                        //TODO处理读取到的数据
                        // ...

                        clientChannel.close();
                    }

                    keyIterator.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  • 资源利用率提升：由于NIO模型使用单个线程处理多个IO操作，可以更有效地利用系统资源，避免了为每个连接创建一个独立线程的资源浪费。
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

public class ResourceUtilizationServer {
    public static void main(String[] args) {
        try {
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.bind(new InetSocketAddress(8080));
            serverSocketChannel.configureBlocking(false);

            Selector selector = Selector.open();
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

            while (true) {
                selector.select();

                Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();
                while (keyIterator.hasNext()) {
                    SelectionKey key = keyIterator.next();

                    if (key.isAcceptable()) {
                        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
                        SocketChannel clientChannel = serverChannel.accept();
                        clientChannel.configureBlocking(false);
                        clientChannel.register(selector, SelectionKey.OP_READ);
                    } else if (key.isReadable()) {
                        SocketChannel clientChannel = (SocketChannel) key.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        clientChannel.read(buffer);
                        buffer.flip();
                        //TODO处理读取到的数据
                        // ...

                        clientChannel.close();
                    }

                    keyIterator.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  • 非阻塞IO操作：NIO模型中的IO操作是非阻塞的，即当没有数据可读取时，IO操作不会被阻塞，而是立即返回。这样可以避免线程被长时间阻塞，提高系统的响应性能。
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

public class NonBlockingIOExample {
    public static void main(String[] args) {
        try {
            SocketChannel socketChannel = SocketChannel.open();
            socketChannel.configureBlocking(false);
            socketChannel.connect(new InetSocketAddress("example.com", 80));

            while (!socketChannel.finishConnect()) {
                //TODO等待连接完成
                //....
            }

            ByteBuffer buffer = ByteBuffer.allocate(1024);
            buffer.put("Hello, Server".getBytes());
            buffer.flip();
            socketChannel.write(buffer);

            buffer.clear();
            socketChannel.read(buffer);
            buffer.flip();
            //TODO处理读取到的数据
            // ...

            socketChannel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  • 选择器机制：NIO模型通过选择器（Selector）来管理多个通道的IO操作。选择器会不断地轮询注册在其上的通道，发现有IO事件发生时进行处理，避免了传统阻塞式IO模型中需要为每个通道创建一个线程的开销。
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;

public class SelectorExample {
    public static void main(String[] args) {
        try {
            Selector selector = Selector.open();

            SocketChannel channel1 = SocketChannel.open();
            channel1.configureBlocking(false);
            channel1.connect(new InetSocketAddress("example.com", 80));
            channel1.register(selector, SelectionKey.OP_CONNECT);

            SocketChannel channel2 = SocketChannel.open();
            channel2.configureBlocking(false);
            channel2.connect(new InetSocketAddress("example.org", 80));
            channel2.register(selector, SelectionKey.OP_CONNECT);

            while (true) {
                selector.select();

                Iterator<SelectionKey> keyIterator = selector.selectedKeys().iterator();
                while (keyIterator.hasNext()) {
                    SelectionKey key = keyIterator.next();

                    if (key.isConnectable()) {
                        SocketChannel channel = (SocketChannel) key.channel();
                        if (channel.isConnectionPending()) {
                            channel.finishConnect();
                        }
                        //TODO 处理连接完成事件
                        // ...
                    }

                    keyIterator.remove();
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
  • 灵活的缓冲区操作：NIO模型使用缓冲区（Buffer）来读取和写入数据，提供了灵活的数据操作方式。可以直接操作缓冲区来读取、写入数据，而无需通过输入流和输出流的方式。
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class BufferExample {
    public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream("input.txt");
            FileOutputStream fos = new FileOutputStream("output.txt");

            FileChannel inputChannel = fis.getChannel();
            FileChannel outputChannel = fos.getChannel();

            ByteBuffer buffer = ByteBuffer.allocate(1024);

            while (inputChannel.read(buffer) != -1) {
                buffer.flip();
                outputChannel.write(buffer);
                buffer.clear();
            }

            inputChannel.close();
            outputChannel.close();

            fis.close();
            fos.close();

            System.out.println("文件复制成功.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

NIO和BIO

区别

  • 阻塞 vs 非阻塞：BIO模型是阻塞式IO模型，即当没有数据可读取时，IO操作会被阻塞，直到有数据可读取。而NIO模型是非阻塞式IO模型，当没有数据可读取时，IO操作不会被阻塞，而是立即返回。

  • 线程模型：BIO模型使用一个线程处理一个连接，当有多个连接时，需要创建多个线程，可能导致资源浪费和性能下降。而NIO模型使用单个线程处理多个连接，通过选择器（Selector）管理多个通道，实现非阻塞的IO操作。

  • 缓冲区操作：BIO模型使用字节流或字符流进行数据读写，而NIO模型使用缓冲区（Buffer）进行数据读写，提供了更灵活的数据操作方式。

作用

  • BIO：BIO模型适用于连接数较少、并发要求不高的简单应用场景。它简单易用，可靠性高，适合于对数据完整性和可靠性要求较高的场景。

  • NIO：NIO模型适用于高并发、大规模的应用场景，可以提高系统的并发处理能力和资源利用率。它具有高性能、非阻塞的特性，适合于对并发性能要求较高的场景。

Miaow.Y.Hu
关注
  • 15
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
java IO NIO AIO.xmind
05-11
涉及到java io, nio, aio相关知识点，学习过程中的一些总结，持续更新中，xmind 格式
Java IO, NIO and NIO.2
03-08
Input/output (I/O) is not a sexy subject, but it’s an important part of non-trivial applications. This book introduces you to most of Java’s I/O capabilities as of Java 8 update 51.
JAVA IO-NIO 详解
04-24
在Java中，IO（输入/输出）是程序与外部世界进行交互的重要桥梁，而NIO（非阻塞IO）则是Java IO的一个重要扩展，它提供了更为高效、灵活的数据处理方式。 传统的Java IO是阻塞式的，即当程序进行读写操作时，如果...
Java IO_NIO
11-23
1、Java IO_NIO 2、Java+IO.pdf
JavaIO和NIO练习
08-16
JavaIO和NIO练习,主要是依据新旧JavaIO所写的一个输出输入流的Demo
mybatisPlus使用MetaObjectHandler对字段进行更新
m0_56356631的博客
04-23 342
都是符合我们的预期的。
string模拟实现
m0_73969414的博客
04-23 1445
c++中string的模拟实现，面试必会知识点
实现自定义注解、实现自定义幂等性注解
qq_44721738的博客
04-23 613
添加 Spring AOP 依赖。创建自定义注解。创建一个新的 Java 注解类，通过@interface关键字来定义，并可以添加元注解以及属性。@Target(ElementType.METHOD) //表示作用于方法上@Retention(RetentionPolicy.RUNTIME) // 表示这个注解在运行时是可见的，这样 AOP 代理才能在运行时读取到这个注解编写 AOP 拦截（自定义注解）的逻辑代码。@Aspect@Component// 方法执行前的处理。
javaweb-SpringBoot基础
kussm_的博客
04-20 1342
Spring的官网(Spring的简介：Spring makes Java simple。Spring Boot 可以帮助我们非常快速的构建应用程序、简化开发、提高效率。创建一个子包controller。
第5 章 Consul服务注册与发现
a13763926743的博客
04-22 761
consul官网地址。
迭代器模式
LuckFairyLuckBaby的博客
04-23 530
迭代器模式(Iterator),提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
Java | 冒泡排序算法实现
yingzix688的博客
04-24 718
题目描述 编写一个Java程序，实现冒泡排序算法。程序需要能够接收一个整型数组作为输入，并输出排序后的数组。 冒泡排序是一种简单的排序算法，它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
java通过Comparator比较器对集合进行多属性连续分组内升降排序，以及null空值排最前或最后
hkl_Forever的博客
04-26 157
一、排序数据准备，分别对 one、two、three 三个属性进行连续分组内排序。连续排序，并且把被排序属性值为null的排在最后。连续排序，并且把被排序属性值为null的排在最后。
@Value
思索的涟漪，突破自我
04-26 194
Value注解是 Spring 框架中的一个注解，用于从属性文件、环境变量、Java 系统属性等地方读取值，并将这些值注入到 Spring 管理的 Bean 中。
【Java并发知识总结 | 第八篇】Java并发线程知识总结
个银二粒的成长之路
04-21 1715
Java并发线程知识总结
DataSource简单示例
最新发布
weixin_42594143的博客
04-26 221
DataSource接口提供了一种标准的方式来获取与数据库的连接，这样可以避免在每次需要连接数据库时都创建新的连接对象，从而提高了应用程序的性能和可伸缩性。以上代码中，通过@Autowired注解将DataSource注入到MyService中，然后使用getConnection()方法获取一个数据库连接，并在try-with-resources语句块中使用连接执行SQL语句。使用DataSource接口可以大大简化数据库连接的管理和使用，同时也能提高应用程序的性能和可伸缩性。
【Java, Git, React】Technical documentation 和 问题汇总解决
清宵尚温的博客
04-21 350
git config --global user.email “邮箱”git config --global user.name “名称”1.1 Git 配置。
@PropertySource的使用
weixin_43970625的博客
04-24 194
这样，当 Spring 应用启动时，它会自动读取这些外部配置，并正确地配置数据源 Bean，无需硬编码任何数据库连接细节。的属性文件，内容如下，该文件位于项目的类路径 (然后，创建一个 Spring 配置类，使用。方法读取属性值，并将这些值应用于数据源 (
Spring Web MVC
2302_82270778的博客
04-20 642
我们可以简单的理解为，Spring Web MVC就是一个框架，它是基于Servlet API构建的原始web框架，它一开始就包含在Spring框架中，它通常被称为"Spring MVC"。下面我们简称之为：Spring MVC在理解什么是Spring MVC之前，我们要清楚什么是MVC？MVC是Model View Controller的缩写，它是软件工程中的一种软件架构设计模式，它把软件系统分为模型、试图和控制器三个基本部分。View(视图)在应用程序中专门用来与浏览器进行交互，展示数据。
JAVA IO 与 NIO 理解
05-24
相比之下，Java NIO 是在 Java 1.4 中引入的新的 API，它是基于块（Block）的操作方式。块是指一块连续的内存区域，Java NIO 中提供了缓冲区（Buffer）来实现块操作。Java NIO 中的主要类和接口有 ByteBuffer、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Miaow.Y.Hu

赏一口饭吃吧，大大们

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值