BIO，NIO，AIO精讲

最新推荐文章于 2022-12-07 13:41:43 发布
最新推荐文章于 2022-12-07 13:41:43 发布
阅读量164 收藏 2
点赞数 3
分类专栏： Netty 文章标签： java bio nio aio netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JavaTeachers/article/details/122219777
版权
本文深入探讨了Java的三种IO模型：BIO、NIO和AIO。BIO是同步阻塞模型，适合连接数目少且固定的架构；NIO是同步非阻塞，通过选择器实现一个线程处理多个请求，适用于连接数目多且短的操作；AIO则是异步非阻塞，由操作系统完成IO操作后通知服务端。通过示例代码展示了三种模型的工作原理和应用场景。
摘要由CSDN通过智能技术生成

IO模型精讲

IO模型就是说用什么样的通道进行数据的发送和接收，Java共支持3种网络编程IO模式：BIO，NIO，AIO

BIO(Blocking IO)

同步阻塞模型，一个客户端连接对应一个处理线程

缺点：
  1. IO代码里read操作是阻塞操作，如果连接不做数据读写操作会导致线程阻塞，浪费资源
  2. 如果线程很多，会导致服务器线程太多，压力太大。
应用场景：

BIO 方式适用于连接数目比较小且固定的架构， 这种方式对服务器资源要求比较高， 但程序简单易理解。
在这里插入图片描述

BIO代码示例

服务端示例

public class SocketServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(9000);
        while (true) {
            System.out.println("等待连接。。");
            //阻塞方法
            Socket socket = serverSocket.accept();
            System.out.println("有客户端连接了。。");
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        handler(socket);
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
            //handler(socket);

        }
    }

    private static void handler(Socket socket) throws IOException {
        System.out.println("thread id = " + Thread.currentThread().getId());
        byte[] bytes = new byte[1024];

        System.out.println("准备read。。");
        //接收客户端的数据，阻塞方法，没有数据可读时就阻塞
        int read = socket.getInputStream().read(bytes);
        System.out.println("read完毕。。");
        if (read != -1) {
            System.out.println("接收到客户端的数据：" + new String(bytes, 0, read));
            System.out.println("thread id = " + Thread.currentThread().getId());

        }
        socket.getOutputStream().write("HelloClient".getBytes());
        socket.getOutputStream().flush();
    }
}

客户端示例

public class SocketClient {

    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1", 9000);
        //向服务端发送数据
        socket.getOutputStream().write("HelloServer".getBytes());
        socket.getOutputStream().flush();
        System.out.println("向服务端发送数据结束");
        byte[] bytes = new byte[1024];
        //接收服务端回传的数据
        socket.getInputStream().read(bytes);
        System.out.println("接收到服务端的数据：" + new String(bytes));
        socket.close();
    }
}

NIO(Non Blocking IO)

同步非阻塞，服务器实现模式为一个线程可以处理多个请求(连接)，客户端发送的连接请求都会注册到多路复用器selector上，多路复用 器轮询到连接有IO请求就进行处理。

I/O多路复用底层一般用的Linux API（select，poll，epoll）来实现，他们的区别如下表：

在这里插入图片描述

应用场景

NIO方式适用于连接数目多且连接比较短（轻操作） 的架构， 比如聊天服务器， 弹幕系统， 服务器间通讯，编程比较复杂， JDK1.4 开 始支持

在这里插入图片描述

NIO 有三大核心组件： Channel(通道)， Buffer(缓冲区)，Selector(选择器)

在这里插入图片描述

  1. channel 类似于流，每个 channel 对应一个 buffer缓冲区，buffer 底层就是个数组
  2. channel 会注册到 selector 上，由 selector 根据 channel 读写事件的发生将其交由某个空闲的线程处理
  3. selector 可以对应一个或多个线程
  4. NIO 的 Buffer 和 channel 都是既可以读也可以写
NIO代码示例：

服务端代码

public class NIOServer {

    //public static ExecutorService pool = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws IOException {
        // 创建一个在本地端口进行监听的服务Socket通道.并设置为非阻塞方式
        ServerSocketChannel ssc = ServerSocketChannel.open();
        //必须配置为非阻塞才能往selector上注册，否则会报错，selector模式本身就是非阻塞模式
        ssc.configureBlocking(false);
        ssc.socket().bind(new InetSocketAddress(9000));
        // 创建一个选择器selector
        Selector selector = Selector.open();
        // 把ServerSocketChannel注册到selector上，并且selector对客户端accept连接操作感兴趣
        ssc.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {
            System.out.println("等待事件发生。。");
            // 轮询监听channel里的key，select是阻塞的，accept()也是阻塞的
            int select = selector.select();

            System.out.println("有事件发生了。。");
            // 有客户端请求，被轮询监听到
            Iterator<SelectionKey> it = selector.selectedKeys().iterator();
            while (it.hasNext()) {
                SelectionKey key = it.next();
                //删除本次已处理的key，防止下次select重复处理
                it.remove();
                handle(key);
            }
        }
    }

    private static void handle(SelectionKey key) throws IOException {
        if (key.isAcceptable()) {
            System.out.println("有客户端连接事件发生了。。");
            ServerSocketChannel ssc = (ServerSocketChannel) key.channel();
            //NIO非阻塞体现：此处accept方法是阻塞的，但是这里因为是发生了连接事件，所以这个方法会马上执行完，不会阻塞
            //处理完连接请求不会继续等待客户端的数据发送
            SocketChannel sc = ssc.accept();
            sc.configureBlocking(false);
            //通过Selector监听Channel时对读事件感兴趣
            sc.register(key.selector(), SelectionKey.OP_READ);
        } else if (key.isReadable()) {
            System.out.println("有客户端数据可读事件发生了。。");
            SocketChannel sc = (SocketChannel) key.channel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            //NIO非阻塞体现:首先read方法不会阻塞，其次这种事件响应模型，当调用到read方法时肯定是发生了客户端发送数据的事件
            int len = sc.read(buffer);
            if (len != -1) {
                System.out.println("读取到客户端发送的数据：" + new String(buffer.array(), 0, len));
            }
            ByteBuffer bufferToWrite = ByteBuffer.wrap("HelloClient".getBytes());
            sc.write(bufferToWrite);
            key.interestOps(SelectionKey.OP_READ | SelectionKey.OP_WRITE);
        } else if (key.isWritable()) {
            SocketChannel sc = (SocketChannel) key.channel();
            System.out.println("write事件");
            // NIO事件触发是水平触发
            // 使用Java的NIO编程的时候，在没有数据可以往外写的时候要取消写事件，
            // 在有数据往外写的时候再注册写事件
            key.interestOps(SelectionKey.OP_READ);
            //sc.close();
        }
    }
}
NIO服务端程序详细分析：
  1. 创建一个 ServerSocketChannel 和 Selector ，并将 ServerSocketChannel 注册到 Selector 上
  2. selector 通过 select() 方法监听 channel 事件，当客户端连接时，selector 监听到连接事件， 获取到 ServerSocketChannel 注册时 绑定的 selectionKey
  3. selectionKey 通过 channel() 方法可以获取绑定的 ServerSocketChannel
  4. ServerSocketChannel 通过 accept() 方法得到 SocketChannel
  5. 将 SocketChannel 注册到 Selector 上，关心 read 事件
  6. 注册后返回一个 SelectionKey, 会和该 SocketChannel 关联
  7. selector 继续通过 select() 方法监听事件，当客户端发送数据给服务端，selector 监听到read事件，获取到 SocketChannel 注册时 绑定的 selectionKey
  8. selectionKey 通过 channel() 方法可以获取绑定的 socketChannel
  9. 将 socketChannel 里的数据读取出来
  10. 用 socketChannel 将服务端数据写回客户端

客户端代码

public class NioClient {
    //通道管理器
    private Selector selector;

    /**
     * 启动客户端测试
     *
     * @throws IOException
     */
    public static void main(String[] args) throws IOException {
        NioClient client = new NioClient();
        client.initClient("127.0.0.1", 9000);
        client.connect();
    }

    /**
     * 获得一个Socket通道，并对该通道做一些初始化的工作
     *
     * @param ip   连接的服务器的ip
     * @param port 连接的服务器的端口号
     * @throws IOException
     */
    public void initClient(String ip, int port) throws IOException {
        // 获得一个Socket通道
        SocketChannel channel = SocketChannel.open();
        // 设置通道为非阻塞
        channel.configureBlocking(false);
        // 获得一个通道管理器
        this.selector = Selector.open();

        // 客户端连接服务器,其实方法执行并没有实现连接，需要在listen（）方法中调
        //用channel.finishConnect() 才能完成连接
        channel.connect(new InetSocketAddress(ip, port));
        //将通道管理器和该通道绑定，并为该通道注册SelectionKey.OP_CONNECT事件。
        channel.register(selector, SelectionKey.OP_CONNECT);
    }

    /**
     * 采用轮询的方式监听selector上是否有需要处理的事件，如果有，则进行处理
     *
     * @throws IOException
     */
    public void connect() throws IOException {
        // 轮询访问selector
        while (true) {
            selector.select();
            // 获得selector中选中的项的迭代器
            Iterator<SelectionKey> it = this.selector.selectedKeys().iterator();
            while (it.hasNext()) {
                SelectionKey key = (SelectionKey) it.next();
                // 删除已选的key,以防重复处理
                it.remove();
                // 连接事件发生
                if (key.isConnectable()) {
                    SocketChannel channel = (SocketChannel) key.channel();
                    // 如果正在连接，则完成连接
                    if (channel.isConnectionPending()) {
                        channel.finishConnect();
                    }
                    // 设置成非阻塞
                    channel.configureBlocking(false);
                    //在这里可以给服务端发送信息哦
                    ByteBuffer buffer = ByteBuffer.wrap("HelloServer".getBytes());
                    channel.write(buffer);
                    //在和服务端连接成功之后，为了可以接收到服务端的信息，需要给通道设置读的权限。
                    channel.register(this.selector, SelectionKey.OP_READ);                                            // 获得了可读的事件
                } else if (key.isReadable()) {
                    read(key);
                }
            }
        }
    }

    /**
     * 处理读取服务端发来的信息 的事件
     *
     * @param key
     * @throws IOException
     */
    public void read(SelectionKey key) throws IOException {
        //和服务端的read方法一样
        // 服务器可读取消息:得到事件发生的Socket通道
        SocketChannel channel = (SocketChannel) key.channel();
        // 创建读取的缓冲区
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int len = channel.read(buffer);
        if (len != -1) {
            System.out.println("客户端收到信息：" + new String(buffer.array(), 0, len));
        }
    }
}
总结
  1. NIO模型的selector 就像一个大总管，负责监听各种IO事件，然后转交给后端线程去处理
  2. NIO相对于BIO非阻塞的体现就在，BIO的后端线程需要阻塞等待客户端写数据(比如read方法)，如果客户端不写数据线程就要阻塞， NIO把等待客户端操作的事情交给了大总管 selector，selector 负责轮询所有已注册的客户端，发现有事件发生了才转交给后端线程处理，后端线程不需要做任何阻塞等待，直接处理客户端事件的数据即可，处理完马上结束，或返回线程池供其他客户端事件继续使用。还有就是 channel 的读写是非阻塞的。 Redis就是典型的NIO线程模型，selector收集所有连接的事件并且转交给后端线程，线程连续执行所有事件命令并将结果写回客户端

在这里插入图片描述

AIO(NIO 2.0)

异步非阻塞， 由操作系统完成后回调通知服务端程序启动线程去处理， 一般适用于连接数较多且连接时间较长的应用

应用场景

AIO方式适用于连接数目多且连接比较长（重操作） 的架构，JDK7 开始支持

代码示例

服务端代码

public class AIOServer {
    public static void main(String[] args) throws Exception {
        final AsynchronousServerSocketChannel serverChannel =
                AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(9000));

        serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
            @Override
            public void completed(AsynchronousSocketChannel socketChannel, Object attachment) {
                try {
                    // 再此接收客户端连接，如果不写这行代码后面的客户端连接连不上服务端
                    serverChannel.accept(attachment, this);
                    System.out.println(socketChannel.getRemoteAddress());
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    socketChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                        @Override
                        public void completed(Integer result, ByteBuffer buffer) {
                            buffer.flip();
                            System.out.println(new String(buffer.array(), 0, result));
                            socketChannel.write(ByteBuffer.wrap("HelloClient".getBytes()));
                        }

                        @Override
                        public void failed(Throwable exc, ByteBuffer buffer) {
                            exc.printStackTrace();
                        }
                    });
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void failed(Throwable exc, Object attachment) {
                exc.printStackTrace();
            }
        });

        Thread.sleep(Integer.MAX_VALUE);
    }
}

客户端代码

public class AIOClient {

    public static void main(String... args) throws Exception {
        AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open();
        socketChannel.connect(new InetSocketAddress("127.0.0.1", 9000)).get();
        socketChannel.write(ByteBuffer.wrap("HelloServer".getBytes()));
        ByteBuffer buffer = ByteBuffer.allocate(512);
        Integer len = socketChannel.read(buffer).get();
        if (len != -1) {
            System.out.println("客户端收到信息：" + new String(buffer.array(), 0, len));
        }
    }
}

BIO、 NIO、 AIO 对比

在这里插入图片描述

同步异步与阻塞非阻塞

老张爱喝茶，废话不说，煮开水。
出场人物：老张，水壶两把（普通水壶，简称水壶；会响的水壶，简称响水壶）。

  1. 老张把水壶放到火上，立等水开。（同步阻塞） 老张觉得自己有点傻
  2. 老张把水壶放到火上，去客厅看电视，时不时去厨房看看水开没有。（同步非阻塞） 老张还是觉得自己有点傻，于是变高端了，买了把会响笛的那种水壶。水开之后，能大声发出嘀~~~~的噪音。
  3. 老张把响水壶放到火上，立等水开。（异步阻塞） 老张觉得这样傻等意义不大
  4. 老张把响水壶放到火上，去客厅看电视，水壶响之前不再去看它了，响了再去拿壶。（异步非阻塞） 老张觉得自己聪明了。

所谓同步异步，只是对于水壶而言。
普通水壶，同步；响水壶，异步。
虽然都能干活，但响水壶可以在自己完工之后，提示老张水开了。这是普通水壶所不能及的。
同步只能让调用者去轮询自己（情况2中），造成老张效率的低下。
所谓阻塞非阻塞，仅仅对于老张而言。
立等的老张，阻塞；看电视的老张，非阻塞。

爪哇_克劳德_武汉
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA BIO、NIO、AIO详解（附代码实现）以及Netty的简介
诺浅的专栏
05-08 1962
这几天在看面试的东西，可能是自己比较笨，花了快两天的时间才理清楚。特此记录一下。 首先我们要理解的一个很重要概念是，客户端连接和传送数据是分开的，连接不代表立马会传输数据。 说说BIO,NIO,AIO到底是什么东西 BIO：同步堵塞 NIO：异步堵塞 AIO：异步非堵塞 看到这里你肯定一脸懵逼，这到底是什么意思，别急，慢慢看。 在JAVA里面IO分两块，一块是操作文件的，一块是操作网...
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的IO模型与Netty概述(BIO/NIO/AIO/Netty)
持之以恒，方得始终
02-08 1240
读完本篇文章将会了解以下问题 1.BIO模型概述 2. NIO模型概述 3. AIO模型概述 4. Netty 5.同步、异步、阻塞、非阻塞 --------------------------------------------------------------------------------------------------------------------------...
Java基础之《netty（8）—AIO介绍》
csj50的专栏
12-07 662
一、AIO基本介绍1、JDK7引入了Asynchronous I/O，即AIO。在进行I/O编程中，常用到两种模式：Reactor（反应器模式）和Proactor。Java的NIO就是Reactor，当有事件触发时，服务端得到通知，进行相应的处理。2、AIO即NIO2.0，叫做异步不阻塞的IO。AIO引入异步通道的概念，采用了Proactor模式，简化了程序编写，有效的请求才启动线程，它的特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用。3、目前AIO还没有广
Netty基础篇-05-Java的AIO
Alan0517
04-05 200
1.简介 JDK 7 引入了 Asynchronous I/O，即 AIO。 在进行 I/O 编程中，常用到两种模式： Reactor和 Proactor。 Java 的 NIO 就是 Reactor，当有事件触发时，服务器端得到通知，进行相应的处理 AIO 即 NIO2.0，叫做异步不阻塞的 IO。AIO 引入异步通道的概念，采用了 Proactor 模式，简化了程序编写，有效的请求才启动线程，它的特点是先由操作系统完成后才通知服务端程序启动线程去处理，一般适用于连接数较多且连接时间较长的应用
java架构之路-（netty专题）初步认识BIO、NIO、AIO
山有山的高度，海有海的胸怀。
02-13 218
　　本次我们主要来说一下我们的IO阻塞模型，只是不多，但是一定要理解，对于后面理解netty很重要的 IO模型精讲 　　IO模型就是说用什么样的通道进行数据的发送和接收，Java共支持3种网络编程IO模式：BIO，NIO，AIO。 BIO 　　BIO(Blocking IO) 同步阻塞模型，一个客户端连接对应一个处理线程。也是我们熟悉的同步阻塞模型，先别管那个同步的概念，我们先来看一下什...
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）。这些通信模型在不同的场景下有着各自的优势，理解和掌握它们对于优化...
Java中BIO、NIO、AIO的理解
08-28
"Java中BIO、NIO、AIO的理解" Java中BIO、NIO、AIO的理解是Java高性能IO体系设计中三个重要的概念。它们都是Java中IO操作的实现方式，但它们之间有着很大的区别。 首先，我们需要了解什么是同步和异步，什么是阻塞...
2024年Java常见的-BIO,NIO,AIO,Netty面试题
最新发布
04-20
### 2024年Java常见BIO、NIO、AIO、Netty面试题解析 #### 一、基础知识概述 1. **IO概念**： - Java中的I/O（Input/Output）指的是输入输出操作，它以流为基础进行数据的输入输出。所有的数据在Java中都是以流的...
Netty5 AIO
04-23
NULL 博文链接：https://shihuan830619.iteye.com/blog/2259258
Netty4核心原理学习之JAVA AIO初体验
HeyDogBro的博客
03-23 173
1、AIO基本原理 AIO(异步I/0 把I/O读写操作完全交给操作系统)，重要的三分分类分别为:AsychronousServerSocketChannel(服务端)、AsynchronousSocketChannel(客户端)、CompletionHandler(用户处理器) 2、AIO初体验(感受服务端和客户端的交互过程) package com.sckj.netty.netty.AIO; import java.io.BufferedReader; import java.io.FileInput
011-Java提供了哪些IO方式？ NIO如何实现多路复用？
weixin_30698527的博客
06-21 316
IO 一直是软件开发中的核心部分之一，伴随着海量数据增长和分布式系统的发展，IO 扩展能力愈发重要。幸运的是，Java 平台 IO 机制经过不断完善，虽然在某些方面仍有不足，但已经在实践中证明了其构建高扩展性应用的能力。 今天我要问你的问题是，Java 提供了哪些 IO 方式？ NIO 如何实现多路复用？ 典型回答 Java IO 方式有很多种，基于不同的 IO 抽象模型和交互方式，可以进行...
基于Netty Spring Boot仿微信聊天项目
haoxiaoyong1014的博客
10-15 3489
基于Netty仿微信聊天项目 功能需求 登录/注册 个人信息 通讯录 搜索好友 添加好友 好友聊天 技术架构–后端 开发工具：IDEA 框架：Spring Boot、MyBatis、Spring MVC、FastDFS、Netty 数据库：mysql 后端项目地址: https://github.com/haoxiaoyong1014/chat-software 技术架构–前端 ...
银行IT系统 -整体架构
congine_mcfeng的专栏
11-11 3034
银行IT系统 -整体架构 --银行系统整体架构及发展方向： 1.网络结构： 1.1 中国国家金融通讯网（China National Financial NetWork）:该系统使中央银行、各商业银行及其他金融机构连接在一起 。 1.2 CNFN三层网络结构： 1.一级节点：国家处理中心（National Processing Center...
几张图解析：银行ODS
AricZhou
12-21 5839
NIO模型讲解
修理男爵的博客
09-18 2737
BIO模型 同步阻塞，一个客户端连接对应一个处理线程。 缺点 代码会阻塞 线程数太多 应用场景 适用于连接数目比较小且固定的架构 NIO模型 同步非阻塞，一个线程可以处理多个请求连接。 多路复用器selector I/O多路复用底层使用的 linux的 api (select、poll、epoll)来实现。 三大核心组件：Channel（通道）、Buffer（缓冲区）、Selector（选择器） channel类似于流 ...
netty aio 实现：
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
02-05 396
public class AIOServer { public static void main(String[] args) throws Exception { final AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.op...
bio nio aio的区别
07-11
Java中的BIO、NIO和AIO是三种不同的I/O模型。 BIO（Blocking I/O）是阻塞式I/O模型，即在进行I/O操作时，线程会一直阻塞直到操作完成。这种模型适用于连接数较少的情况，但在高并发环境下会导致线程阻塞，资源浪费。 NIO（Non-blocking I/O）是非阻塞式I/O模型，即在进行I/O操作时，线程不会一直阻塞，而是可以继续执行其他任务。这种模型适用于连接数较多的情况，可以提高系统的并发性能。 AIO（Asynchronous I/O）是异步I/O模型，即在进行I/O操作时，线程不需要等待操作完成，而是可以继续执行其他任务。这种模型适用于I/O操作时间较长的情况，可以提高系统的吞吐量。 总之，BIO适用于连接数较少的情况，NIO适用于连接数较多的情况，而AIO适用于I/O操作时间较长的情况。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值