BIO、NIO

最新推荐文章于 2023-03-06 13:38:41 发布
最新推荐文章于 2023-03-06 13:38:41 发布
阅读量2.9k 收藏 2
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/songfei_dream/article/details/104236914
版权

1. BIO和NIO

我们平常使用的IO是BIO（Blocking-IO），即阻塞IO、而NIO（No-blocking-IO）则是非阻塞IO，二者有什么区别呢？

预先知识准备
  • 同步：发起调用后，调用者一直处理任务至结束后才返回结果，期间不能执行其他任务
  • 异步：发起调用后，调用者立即返回结果的标记（当结果出来后用回调等机制通知），期间可以执行其他任务
  • 阻塞：发起请求后，发起者一直等待结果返回，期间不能执行其他任务
  • 非阻塞：发起请求后，发起者不用一直等待结果，期间可以执行其他任务
  • IO模式有五种（同步、异步、阻塞、非阻塞、多路复用）这里介绍同步阻塞和同步非阻塞IO，而剩下的后面回来填坑

NIO主要体现在网络IO中，所以下面就围绕网络IO来说明，这里会涉及到传统的BIO、网络编程、反应器设计模式，如果不了解的童鞋这里有各自的传送门 BIO ，[未完善]

二者区别
BIONIO
类型同步阻塞同步非阻塞
面向面向流面向缓冲区
组件无选择器

若没有了解过NIO，那么列出的区别只需有个印象即可，后面会逐步说明

2.BIO

2.1 传统BIO

传统的IO其读写操作都阻塞在同一个线程之中，即在读写期间不能再接收其他请求

那么我们就来看看传统BIO是怎么实现的，后面都以网络编程的Socket为例，因其与后面的NIO有关

public class BIO {
    
    public static void main(String[] args) throws IOException {
        
        // 开个线程运行服务器端套接字
        new Thread( () -> {
            try {
                // 建立服务器端套接字
                ServerSocket serverSocket = new ServerSocket(8080);
                // 该方法阻塞至有请求过来
                Socket socket = serverSocket.accept();

                // 获取输入流
                int length = 0;
                byte[] bytes = new byte[1024];
                InputStream in = socket.getInputStream();

                // 客户端关闭输出流这里才会读取到-1,shutdownOutput或者close
                while( (length = in.read(bytes)) != -1){
                    System.out.println(new String(bytes,0,length));
                }

                System.out.println("这里服务器端处理任务花费了10秒");
                Thread.sleep(10000);

                // 获取输出流
                OutputStream out = socket.getOutputStream();
                out.write( ("这里是服务器端发送给客户端的消息: " + new Date()).getBytes() );

                // 关闭资源
                in.close();
                out.close();
                socket.close();
                serverSocket.close();
            } catch (Exception e) {
            }
        }).start();
        
        
        
        
        // 开个线程运行客户端套接字
        new Thread( () -> {
            try {
                // 建立客户端套接字
                Socket socket = new Socket("127.0.0.1",8080);
                
                // 获取输出流
                OutputStream out = socket.getOutputStream();
                out.write( ("这里是客户端发送给服务器端的消息：" + new Date()).getBytes() );
                // 关闭输出流,让服务器知道数据已经发送完毕，剩下接收数据了
                socket.shutdownOutput();
                
                // 获取输入流
                int length = 0;
                byte[] bytes = new byte[1024];
                InputStream in = socket.getInputStream();
                while( (length = in.read(bytes)) != -1){
                    System.out.println(new String(bytes,0,length));
                }
                
                // 关闭资源，若没有关闭则会保持连接至超时，单线程服务器端就不能接收后来的连接请求
                out.close();
                in.close();
                socket.close();
            } catch (Exception e) {
            }
        }).start();

    }
}
这里是客户端发送给服务器端的消息：Sat Feb 08 15:14:55 GMT+08:00 2020
这里服务器端处理任务花费了10秒
这里是服务器端发送给客户端的消息: Sat Feb 08 15:15:05 GMT+08:00 2020

  • 从输出可以看出，客户端会一直等待阻塞直至服务器端返回内容

  • 服务器端的accept()方法会阻塞当前线程，直至有请求发送过来才会继续accept()方法下面的代码
  • 服务器端接收到一个请求后且该请求还没处理完，后又再有一个请求过来，则后来的请求会被阻塞需排队等待
  • 客户端打开输出流若没关闭，则服务器端是不知道客户端数据已经发送完，会一直等待至超时 ，关闭方法：
    • 客户端socket.close()，整个连接也关闭了
    • 客户端socket.shutdownOutput()，单方面关闭输出流，不关闭连接
    • 客户端的outputStream.close()，会造成socket被关闭

2.2 伪异步BIO

传统的BIO是单线程的，一次只能处理一个请求，而我们可以改进为多线程，即服务器端每接收到一个请求就为该请求单独创建一个线程，而主线程还是继续监听是否有请求过来，伪异步是因为accept方法到底还是同步的

public class SocketTest {
    
    // 定义线程接口
    class MyRunnable implements Runnable{
        
        @Override
        public void run(){
            try {
                Socket socket = new Socket("127.0.0.1",8080);
                
                // 获取输出流
                OutputStream out = socket.getOutputStream();
                out.write( ("这里是客户端发送给服务器端的消息：" + new Date()).getBytes() );
                // 关闭输出流,让服务器知道数据已经发送完毕，剩下接收数据了
                socket.shutdownOutput();
                
                // 获取输入流
                int length = 0;
                byte[] bytes = new byte[1024];
                InputStream in = socket.getInputStream();
                while( (length = in.read(bytes)) != -1){
                    System.out.println(new String(bytes,0,length));
                }
                
                // 关闭资源
                out.close();
                in.close();
                socket.close();
            } catch (Exception e) {
            }
        }
    }
    
    
    
    public static void main(String[] args) throws IOException, InterruptedException {
        
        // 开个线程运行服务器端套接字
        new Thread( () -> {
            try {
                // 建立服务器端套接字
                ServerSocket serverSocket = new ServerSocket(8080);
                
                // 循环接收请求
                while(true){
                    Socket socket = serverSocket.accept();
                    
                    // 为每个请求单独开线程，这里就不那么复杂使用线程池了
                    new Thread( () -> {
                        try {
                            // 获取输入流
                            int length = 0;
                            byte[] bytes = new byte[1024];
                            InputStream in = socket.getInputStream();
                            while( (length = in.read(bytes)) != -1){
                                System.out.println(new String(bytes,0,length));
                            }
                            
                            // 获取输出流
                            OutputStream out = socket.getOutputStream();
                            out.write( ("这里是服务器端发送给客户端的消息: " + new Date()).getBytes() );
                            
                            // 关闭资源
                            in.close();
                            out.close();
                            socket.close();
                        } catch (Exception e) {
                            // TODO: handle exception
                        }
                    }).start();
                }
            } catch (Exception e) {
            }
        }).start();
        
        
        // 创建多线程，调用类中接口（为了偷懒写成这样了。。。）
        // 关注点在于伪异步，像线程计数器，，线程池，Lambda表达式也尽量少用，使代码易懂
        SocketTest socketTest = new SocketTest();
        MyRunnable myRunnable = socketTest.new MyRunnable();
        new Thread(myRunnable).start();
        new Thread(myRunnable).start();
        new Thread(myRunnable).start();

    }
}
这里是客户端发送给服务器端的消息：Sat Feb 08 15:52:00 GMT+08:00 2020
这里是服务器端发送给客户端的消息: Sat Feb 08 15:52:00 GMT+08:00 2020
这里是客户端发送给服务器端的消息：Sat Feb 08 15:52:00 GMT+08:00 2020
这里是客户端发送给服务器端的消息：Sat Feb 08 15:52:00 GMT+08:00 2020
这里是服务器端发送给客户端的消息: Sat Feb 08 15:52:00 GMT+08:00 2020
这里是服务器端发送给客户端的消息: Sat Feb 08 15:52:00 GMT+08:00 2020
  • 服务器端每来一个请求就为之单独创建线程来处理任务，使主线程可以继续循环接收请求
  • 客户端的请求之间就互不干扰了，不用等待上一个请求处理完才处理下一个
  • 其本质还是同步，使用了多线程才实现异步功能
  • 使用多线程，若在多高并发情况下，会大量创建线程而导致内存溢出（可以使用线程池优化，但有界限池终究不是办法）

3. NIO

  • 看了上面那么多铺垫，终于到我们的正题了。NIO主要使用在网络IO中，当然文件IO也有使用，NIO在高并发的网络IO中有极大的优势，其在JDK1.4中引入，以我们传统再传统的开发环境--1.7中可以使用了
  • 在单线程中，NIO在写读数据的时候可以同时执行其他任务，不必等数据完全读写而导致阻塞（后面有地方说明）

NIO的组成

  • Buffer（缓冲区）
  • Channel（通道）
  • Selector（选择器）

那么我们就来看看NIO的三个组成把

3.1 Buffer

NIO是面向缓冲区的，一次处理一个区的数据，在NIO中我们都是使用缓冲区来处理数据，即数据的读入或写出都要经过缓冲区

缓冲区的类型有：

  • ByteBuffer、

  • ShortBuffer、

  • IntBuffer、

  • LongBuffer、

  • FloatBuffer、

  • DoubleBuffer、

  • CharBuffer

最常用是ByteBuffer，记住后面要用到，可使用静态方法获取缓冲区：ByteBuffer.allocate(1024)

Buffer类中主要的方法：

返回类型函数解释
XXXBufferallocate(int capacity)返回指定容量的缓冲区
ByteBufferput(byte[] src)向缓冲区添加字节数组
ByteBufferget(byte[] dst)向缓冲区获取字节数组
XXXBufferflip()切换成读模式
XXXBufferclear()清除此缓冲区

其内部维护了几个变量

// Invariants: mark <= position <= limit <= capacity
private int mark = -1;  // 标记这里不讲解
private int position = 0;   //位置
private int limit;      // 限制
private int capacity;   // 容量大小

变量的变化：

初始化时：position为0，limit和capacity为容量大小，且capacity不变化，后面省略

put数据时：position为put进去数据大小（如放进5字节数据，则position=5），其余不变，正常默认为写模式

切换读模式：limit赋值为position的当前值，而position赋值为0

get数据时：读取多少个数据，position就前进几个位置

清空：调用clear()，变量变为初始化状态，即position为0，limit为容量大小

3.2 Channel

通道主要是传输数据的，不进行数据操作，并且与流不同可以前后移动，而且通道是双向的读写的，最重要的是Channel只能与Buffer交互，所以要使用NIO就要用Channel和Buffer来配合

其类型包括：

  • FileChannel
  • DatagramChannel
  • SocketChannel:
  • ServerSocketChannel

可以看出NIO主要支持网络IO及文件IO，可通过静态方法获取：ServerSocketChannel.open()，然后通过ServerSocketChannel.socket()获取对应的套接字，套接字的获取通道方法前提是已经绑定了通道才行，不然空指针

通道的主要方法：

类型函数名解释
ServerSocketChannelopen返回对应的通道
intread(ByteBuffer dst)从该通道读取到给定缓冲区的字节序列
intwrite(ByteBuffer src)从给定的缓冲区向该通道写入一个字节序列
ServerSocketChannelbind(SocketAddress local)将通道的套接字绑定到本地，设为监听连接
SelectableChannelconfigureBlocking(Boolean bool)设置通道的阻塞模式
SelectionKeyregister(Selector sel, int ops)将通道注册到选择器

配合Channel和Buffer来简单实现数据流通

int length = 0;
while( (length = inChannel.read()) != -1 ){
    buffer.flip();  //切换读模式
    outChannel.write(buffer);   // 数据写入通道
    buffer.clear();     // 清空缓冲区，实现可再写入
}

3.3 Selector

NIO特有的组件（选择器容器），注意只有在网络IO中才具有非阻塞性，网络IO中的套接字的通道才有非阻塞的配置。使用单线程通过Selector来轮询监听多个Channel，在IO事件还没到达时不会陷入阻塞态等待。划重点：传统BIO在事件还没到达时该线程会被阻塞而等待，一次只能处理一个请求（可以使用多线程来提高处理能力）。而NIO在事件还没到达是非阻塞轮询监听的，一次可以处理多个事件。使用一个线程来处理多个事件明显比一个线程处理一个事件更优秀，获取选择器：Selector.open()

选择器主要方法：

类型方法名解释
voidclose关闭此选择器
Selectoropen打开选择器
intselect选择一组准备好的IO键
Set selectedKeys返回选择器的键集

这里补充一下注册通道时返回的键的方法

XXXChannelchannel返回键对应的通道，类似于句柄
booleanisAcceptable键对应的通道是否准备好了
booleanisReadable键对应的通道是否可读
booleanisWritable键对应的通道是否可写

3.4 使用事例

综合上面BIO的 2.1和 2.2的代码，客户端基本不用改动，使用多线程来模拟多次请求，而重点改造在于服务器端

这里的服务器端用单线程来处理请求，即一对多使用了多路复用。若是BIO单线程则会阻塞，即一请求一应答

public class NIOTest {0.
    
    // 定义线程接口
        class MyRunnable implements Runnable{
            
            @Override
            public void run(){
                try {
                    Socket socket = new Socket("127.0.0.1",8080);
                    
                    // 获取输出流
                    OutputStream out = socket.getOutputStream();
                    out.write( ("这里是客户端发送给服务器端的消息：" + new Date()).getBytes() );
                    // 关闭输出流,让服务器知道数据已经发送完毕，剩下接收数据了
                    socket.shutdownOutput();
                    
                    // 获取输入流
                    int length = 0;
                    byte[] bytes = new byte[1024];
                    InputStream in = socket.getInputStream();
                    while( (length = in.read(bytes)) != -1){
                        System.out.println(new String(bytes,0,length));
                    }
                    
                    // 这里故意不关闭资源，保持连接
                    // 如果是BIO单线程，没有断开连接，则会阻塞后面的请求
                    // 而NIO则不会阻塞，因为是多路复用
                    
                } catch (Exception e) {
                }
            }
        }
    
    

    public static void main(String[] args) throws UnknownHostException, IOException {
        
        // 开个线程运行服务器端套接字
        new Thread( () -> {
            
            try {
                // 静态方法获取选择器
                // 开启选择器的线程会被选择器阻塞，所以要另开一个线程执行
                Selector selector = Selector.open();
                
                // 获取服务器端通道并配置非阻塞
                ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
                serverSocketChannel.configureBlocking(false);
                InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 8080);
                serverSocketChannel.bind(inetSocketAddress);
                
                // Selector管理Channel，则需将对应的channel注册上去，且指定类型
                // 将服务器通道注册到选择器上,注册为accept
                // 可频道为：一看能看出来不解释了
                /**
                 * SelectionKey.OP_CONNECT
                 * SelectionKey.OP_ACCEPT
                 * SelectionKey.OP_READ
                 * SelectionKey.OP_WRITE
                 */
                serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
                
                while(true){
                    // 轮询监听是否有准备好的连接
                    if(selector.select() > 0){
                        // 获取键集
                        Set<SelectionKey> set = selector.selectedKeys();
                        Iterator iterator = set.iterator();
                        // 迭代器迭代
                        while(iterator.hasNext()){
                            SelectionKey selectionKey = (SelectionKey) iterator.next();
                            
                            // 接收连接事件
                            if(selectionKey.isAcceptable()){
                                SocketChannel socketChannel = serverSocketChannel.accept();
                                
                                // 设置客户端通道为非阻塞，不然选择器会被阻塞，其存在没有意义了
                                socketChannel.configureBlocking(false);
                                
                                // 将客户端通道注册到选择器上，使选择器可以统一管理
                                socketChannel.register(selector, SelectionKey.OP_READ);
                                
                            // 处理可读事件
                            }else if(selectionKey.isReadable()){
                                // 通过key来获取通道
                                SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
                                
                                // 配合缓冲区
                                ByteBuffer bytebuffer = ByteBuffer.allocate(1024);
                                
                                int length = 0;
                                byte[] bytes = new byte[1024];
                                while( (length = socketChannel.read(bytebuffer)) != -1){
                                    bytebuffer.flip();
                                    
                                    // 将缓冲区数据放入字节数组，并输出
                                    bytebuffer.get(bytes, 0, length);
                                    System.out.println(new String(bytes,0,length));
                                    
                                    bytebuffer.clear();
                                }
                            }
                            // 取消选择键，因为有些已经处理了
                            iterator.remove();
                        }
                    }
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }).start();
        
        
        // 调用类中接口，创建多线程（为了偷懒写成这样了。。。）
        NIOTest NIOTest = new NIOTest();
        MyRunnable myRunnable = NIOTest.new MyRunnable();
        new Thread(myRunnable).start();
        new Thread(myRunnable).start();
        new Thread(myRunnable).start();

    }
}
  • 上面客户端故意不关闭连接，未超时情况下也能处理多请求，则说明NIO是非阻塞的，最大好处就在于这里

总结

挖坑：AIO异步的IO，基于网络编程的Netty框架，越来越多的坑要填了 —_—!

雨落无影
关注
BIO和NIO
横竖里的博客
07-01 237
IO IO 的方式通常分为几种：同步阻塞的 BIO、同步非阻塞的 NIO、异步非阻塞的 AIO。 BIO 在 JDK1.4 之前，我们建立网络连接的时候只能采用 BIO，需要先在服务端启动一个ServerSocket，然后在客户端启动 Socket 来对服务端进行通信，默认情况下服务端需要对每个请求建立一个线程等待请求，而客户端发送请求后，先咨询服务端是否有线程响应，如果没有则会一直等待或者遭到拒...
Java的IO流 ，BIO NIO AIO 的区别？
qq_45071235的博客
03-19 576
目录 1.在了解不同的IO之前先了解：同步与异步，阻塞与非阻塞的区别: 2.BIO NIO AIO 分别代表什么？（面试简答）： 3.BIO和NIO、AIO的区别: 4.java中io流的分类： • FileInputStream（按照字节输入） • FileOutputStream（按照字节输出） • FileReader(字符输入) • FileWriter（字符输出） • 节点流与处理流 节点流和处理流的区别和联系 ： • BufferedReader/Buff...
转BIO，NIO和AIO讲的很明白的文章
lengyue309的博客
10-31 3788
到底什么是“IO Block” 很多人说BIO不好，会“block”，但到底什么是IO的Block呢？考虑下面两种情况： 用系统调用read从socket里读取一段数据 用系统调用read从一个磁盘文件读取一段数据到内存 如果你的直觉告诉你，这两种都算“Block”，那么很遗憾，你的理解与Linux不同。Linux认为： 对于第一种情况，算作block，因为Linux无法知道网络上对方...
关于BIO和NIO的理解
weixin_34381666的博客
10-23 495
2019独角兽企业重金招聘Python工程师标准>>> ...
BIO、NIO介绍
qq_35599414的博客
12-04 195
IO：https://blog.csdn.net/qq_35751014/article/details/104715499 BIO+NIO:https://blog.csdn.net/foolishpichao/article/details/108193606 NIO:https://blog.csdn.net/qq_35751014/article/details/104411347 参考视频：https://www.bilibili.com/video/BV1DJ411m7NR?p=37 .
bio nio aio demo
04-11
为了处理与外部世界的交互，Java提供了三种不同的I/O模型：BIO（ Blocking I/O）、NIO（Non-blocking I/O）和AIO（Asynchronous I/O）。这些模型各有优缺点，适用于不同场景。下面我们将深入探讨这三种I/O模型，并...
java BIO NIO AIO
07-18
Java BIO NIO AIO Java BIO、NIO、AIO是 Java 中的三种 I/O 模式，每种模式都有其特点和应用场景。下面对每种模式进行详细解释。 Java BIO Java BIO（ Blocking I/O）是一种同步阻塞式的 I/O 模式，即服务器实现...
基于java的BIO、NIO、AIO通讯模型代码实现
03-24
Java作为一门广泛使用的开发语言，提供了多种I/O（Input/Output）通信模型，包括传统的阻塞I/O（BIO）、非阻塞I/O（NIO）以及异步I/O（AIO）。这些通信模型在不同的场景下有着各自的优势，理解和掌握它们对于优化...
详解 同步异步、阻塞非阻塞 与 BIO NIO AIO区别、多路复用
Java技术攻略的博客
03-06 434
BIO（同步阻塞）：你到饭馆点餐，然后在那等着，啥都干不了，餐没做好，你就必须等着！NIO（同步非阻塞）：你在饭馆点完餐，就去玩儿了。不过玩一会儿，就回饭馆问一声：好了没？AIO（异步非阻塞）：饭馆打电话说，我们知道您的位置，一会给你送过来，安心玩儿就可以了，类似于外卖。哪种方式更有效率呢？是不是一目了然呢？BIO：同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。
bio，io，nio
青鱼入云的博客
05-14 281
io，nio
BIO NIO AIO
weixin_44119660的博客
06-11 140
阻塞与非阻塞 线程访问资源，该资源是否准备就绪的一种处理方式 阻塞: 线程请求资源，等待资源处理返回结果 非阻塞: 线程请求资源，若资源在处理中不等待直接请求下一个资源 同步与异步 同步和异步指访问数据的一种机制 同步：主动请求，等待资源处理后的返回通知，才能够发送下一个请求 异步：发送一个请求，不用等待，随时发送下一个请求，等资源处理完毕之后接收异步通知 BIO NIO AIO ...
BIO/NIO/AIO
China_110的博客
04-02 317
BIO/NIO/AIO 几个概念 阻塞IO 和非阻塞IO 这两个概念是程序级别的。主要描述的是程序请求操作系统IO操作后，如果IO资源没有准备好，那么程序该如何处理的问题：前者等待；后者继续执行（但是使用线程一直轮询，直到有 IO资源准备好了）。 同步IO 和 异步IO，这两个概念是操作系统级别的。主要描述的是操作系统在收到程序请求IO操作后，如果IO资源没有准备好，该如何响应程序的问题：前者不...
理解BIO、NIO这一篇就够了
apple_52109766的博客
07-30 568
title: IO流详解 date: 2021-07-29 00:14:32 此笔记源于B站黑马BIO、NIO教程 视频教程 第一章 Java的I/O演进之路 1.1 I/O 模型基本说明 I/O 模型：就是用什么样的通道或者说是通信模式和架构进行数据的传输和接收，很大程度上决定了程序通信的性能，Java 共支持 3 种网络编程的/IO 模型：BIO、NIO、AIO 实际通信需求下，要根据不同的业务场景和性能需求决定选择不同的I/O模型 1.2 I/O模型 Java BIO 同步并阻塞(传统阻塞型)，服务.
NIO/BIO
qq_33849244的博客
01-19 1613
1）阻塞(Block)和非租塞(NonBlock): 阻塞和非阻塞是进程在访问数据的时候，数据是否准备就绪的一种处理方式，当数据没有准备的时候阻塞：往往需要等待缞冲区中的数据准备好过后才处理其他的事情，否則一直等待在那里。 非阻塞：当我们的进程访问我们的数据缓冲区的时候，如果数据没有准备好则直接返回，不会等待。如果数据已经准备好，也直接返回 2）同步(Synchronization)和异步(...
BIO与NIO比较
liangcheng0213的博客
07-23 718
文章目录BIO 同步阻塞BIO介绍BIO的编程流程BIO实现通信实现思路：服务器：客户端： BIO 同步阻塞 服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动 一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销 BIO介绍 Java BIO 就是传统的 java io 编程，其相关的类和接口在 java.ioBIO(blocking I/O) ： 同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做..
Java核心（五）深入理解BIO、NIO、AIO
moneywenxue的博客
02-04 203
导读：本文你将获取到：同/异步 + 阻/非阻塞的性能区别；BIO、NIO、AIO 的区别；理解和实现 NIO 操作 Socket 时的多路复用；同时掌握 IO 最底层最核心的操作技巧。 BIO、NIO、AIO 的区别是什么？ 同/异步、阻/非阻塞的区别是什么？ 文件读写最优雅的实现方式是什么？ NIO 如何实现多路复用功能？ 带着以上这几个问题，让我们一起进入IO的世界吧。 在开始之前，我们先来思考一个问题：我们经常所说的“IO”的全称到底是什么？ 可能很多人看到这个问题和我一样一脸懵逼，
NIO和BIO的比较
Yolyn‘s blog
08-07 5346
NIO和BIO的比较1. NIO和BIO的比较2. NIO中三大组件关系2.1 Buffer2.2 Channel（通道）2.3 Buffer和Channel的注意事项和细节。2.4 Selector（选择器） 1. NIO和BIO的比较 BIO以流的方式处理数据，而NIO以块的方式处理数据，块I/O的效率比流I/O高很多。 BIO是阻塞的，NIO是非阻塞的 BIO基于字节流和字符流进行操作，而NIO是基于Channel（通道）和Buffer（缓冲区）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写
aio bio nio区别
最新发布
05-29
aio、bio、nio 都是 Java 中实现 IO 操作的方式，它们有以下区别： 1. BIO（Blocking I/O）：同步阻塞 I/O 模式，数据的读取写入必须阻塞在一个线程内等待其完成。在高并发的情况下，由于线程阻塞会导致系统资源的浪费，性能表现较差。 2. NIO（Non-blocking I/O）：同步非阻塞 I/O 模式，数据的读取写入不需要阻塞线程，可以通过轮询机制实现非阻塞。NIO 的特点是可以处理多个连接，但是编程模型较为复杂，需要了解选择器、通道、缓冲区等概念。 3. AIO（Asynchronous I/O）：异步非阻塞 I/O 模式，数据的读取写入是异步的，不需要等待数据传输完成才返回。AIO 是 Java 1.7 中才有的异步 I/O 操作，相比于 NIO 更加高效，因为 AIO 不需要通过轮询机制来等待数据的读写完成，而是在数据传输完成后会通过回调函数通知应用程序。 总之，BIO、NIO、AIO 都是 Java 中实现 I/O 操作的方式，它们各有优缺点，应根据具体的应用场景选择合适的方式。BIO 是最简单的 I/O 操作方式，但是性能较差，适合处理连接数较少的场景。NIO 可以处理更多的连接，但编程模型较为复杂。而 AIO 则是最高效的 I/O 操作方式，适合高并发的场景。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值