备案控制台
开发者社区 开发与运维 文章 正文

通俗易懂的JAVA BIO NIO AIO 原理白话文解释，区别，优缺点及代码使用案例

2023-02-22 191
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 通俗易懂的JAVA BIO NIO AIO 原理白话文解释，区别，优缺点及代码使用案例

BIO 介绍与原理

BIO 全程Blocking I/O ，阻塞io, 是java最早的 网络io模型

基于基本ServerSocket ，Socket 实现,

SOCKET 所有的操作都是基于阻塞IO的，比如socket inpustream read方法

如果没有数据进来就会一直阻塞，除非新创建线程处理每一个socket

BIO 匹配我们饭店吃饭场景

我们先到第一个窗口，发现厨师还没做好，那么就一直等着，直到这到菜做好了，我们拿到这个菜，然会回到座位吃完了

然后又去第二个窗口，等待第二道菜做好，然后拿回座位吃完，以此循环下去

以上场景可以匹配ServerSocket 的accept 方法，以及Socket 的read write方法

一般解决方案是每一个socket 启用一个thread 处理，这会导致并发数很低

BIO 优缺点：

优点：代码通俗易懂，在低并发场景或者分布式场景依然应用很广

缺点: 所有流程都是阻塞模式，需要依赖创建多个thread 处理每个socket，并发量很低


BIO运行图：



5e44031affb4453cb40404435e9f9356.png

BIO 案例代码：

服务端最简单示例：

创建服务端有客户端连接后发送hello 字符串，并接受客户端reply 回复

/**
     * @description: demos of jdk8 java.net.ServerSocket class
     * 创建服务端，有客户端连接后发送hello 字符串，并接受客户端reply 回复
     *
     * */
    @Test
    public void testServer() throws IOException {
        ServerSocket serverSocket = new ServerSocket(8679);
        while(true){
            Socket socket = serverSocket.accept();
            socket.getOutputStream().write("hello".getBytes());
            try{
                ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                byte[] bytes = new byte[1024];
                int read = 0;
                while ((read =socket.getInputStream().read(bytes))>0){
                    byteBuffer.put(bytes,0,read);
                    byteBuffer.flip();
                    String rs = new String(byteBuffer.array());
                    System.out.println(rs);
                    byteBuffer.clear();
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                if(!socket.isClosed()) {
                    try {
                        socket.close();
                    }catch (Exception e1){
                        e1.printStackTrace();
                    }
                }
            }
        }
    }

客户端最简单示例：

创建客户端，连接到服务端后接收到hello 字符串，并接向服务端发送reply 字符串回复 

 /**
     * @description: demos of jdk8 java.net.Socket class
     * 创建客户端，连接到服务端后接收到hello 字符串，并接向服务端发送reply 字符串回复
     */
    @Test
    public void testClient() throws IOException {
        Socket socket = new Socket("127.0.0.1", 8679);
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        byte[] bytes = new byte[1024];
        int read = 0;
        while ((read = socket.getInputStream().read(bytes)) > 0) {
            byteBuffer.put(bytes, 0, read);
            byteBuffer.flip();
            String rs = new String(byteBuffer.array());
            byteBuffer.clear();
            System.out.println(rs);
            socket.getOutputStream().write("reply".getBytes());
        }
    }

NIO 介绍与原理

NIO 全称 non-blocking I/O ，意思是非阻塞io

与上面BIO 对应的，是JAVA 后加入的nio 包内的网络io模型

核心类是Selector ,    ServerSocketChannel,SocketChannel

NIO 匹配我们饭店吃饭场景

同样是进了一个饭店，饭店有几个窗口，每个窗口做不同的菜，比如宫保鸡丁，油闷大虾，醋溜鱼等等

我们这次选择另一种方式等菜，我们不断的在每个窗口走来走去，而不是一直等在某个窗口

每一轮查看就把所有做好的菜一起打包带走，拿回来放到桌上吃完，然后在去窗口再继续一轮轮循环往复

这样做对程序来说的好处就是一直只有一个线程在不断循环监听某些事件就绪了也就是Selector的select()方法，相当于上面的查看哪些菜好了

NIO 优缺点：

优点：这样做极大的压缩了需要使用的线程，极大的提高了并发量

确定：在高并发场景下会有阻塞问题，因为在处理某个任务的时候其他事件的处理需要等待

NIO运行图：

NIO 案例代码：

NIO 服务端最简单示例：

创建服务端，有客户端连接后发送hello 字符串，并接受客户端reply 回复

 /**
     * @description: demos of jdk8 java.nio.ServerSocketChannel class
     * java.nio.ServerSocketChannel 作用：ServerSocketChannel 是 socket nio server 服务端
     * ServerSocketChannel 例子：
     * nio 服务端简单demo,流程如下
     * 1. 服务端创建并注册OP_ACCEPT事件到selector 中
     * 2. 循环获取selector中事件
     * 2.1 如果是OP_ACCEPT 事件,则获取到对应连接的客户端socketChannel
     * 2.2 将socketChannel 注册读事件OP_READ到selector 中
     * 2.3 如果是OP_READ ,则读取信息
     */
    @Test
    public void testServerSocketChannel() throws IOException {
        Selector selector = Selector.open();
        ServerSocketChannel ssc = ServerSocketChannel.open();
        ssc.bind(new InetSocketAddress(8970));
        ssc.configureBlocking(false);
        ssc.register(selector, SelectionKey.OP_ACCEPT);
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        while (true) {
            selector.select();
            Iterator<SelectionKey> skIterator = selector.selectedKeys().iterator();
            while (skIterator.hasNext()) {
                SelectionKey sk = skIterator.next();
                try {
                    if (sk.isValid() && sk.isAcceptable()) {
                        ServerSocketChannel assc = (ServerSocketChannel) sk.channel();
                        SocketChannel asc = assc.accept();
                        asc.configureBlocking(false);
                        asc.register(selector, SelectionKey.OP_READ);
                        byteBuffer.clear();
                        byteBuffer.put("hello".getBytes());
                        byteBuffer.flip();
                        asc.write(byteBuffer);
                    }
                    if (sk.isValid() && sk.isReadable()) {
                        SocketChannel sc = (SocketChannel) sk.channel();
                        byteBuffer.clear();
                        sc.read(byteBuffer);
                        byteBuffer.flip();
                        String rs = new String(byteBuffer.array());
                        System.out.println(rs);
                    }
                    skIterator.remove();
                } catch (Exception e) {
                    //e.printStackTrace();
                    sk.cancel();
                    sk.channel().close();
                }
            }
        }
    }

客户端最简单示例：

创建客户端，连接到服务端后接收到hello 字符串，并接向服务端发送reply 字符串回复

/**
     * @description: demos of jdk8 java.nio.ServerChannel class
     * java.nio.ServerChannel 作用：ServerChannel 是 客户端
     * ServerChannel 例子：
     */
    @Test
    public void testServerChannel() throws IOException {
        SocketChannel sc = SocketChannel.open(new InetSocketAddress("127.0.0.1", 8970));
        sc.configureBlocking(false);
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        while (true) {
            byteBuffer.clear();
            while (sc.read(byteBuffer) > 0) {
                byteBuffer.flip();
                String rs = new String(byteBuffer.array());
                System.out.println(rs);
                byteBuffer.clear();
                byteBuffer.put("reply".getBytes());
                byteBuffer.flip();
                sc.write(byteBuffer);
            }
        }
    }

AIO 介绍与原理

AIO 全称 Asynchronous I/O ，意思是异步io，属于完全的非阻塞io

也是NIO 包内的异步网络io模型 ，与上面NIO 相比，去掉了循环监听事件并收集取回遍历的过程核心类是 AsynchronousServerSocketChannel AsynchronousSocketChannel CompletionHandler

AIO 匹配我们饭店吃饭场景

我也又进入了这家饭店，饭店有几个窗口，每个窗口做不同的菜，比如宫保鸡丁，油闷大虾，醋溜鱼等等这次我们换了一种更方便的方式，我们不在每个窗口前走来走去看哪个菜好了

而是告诉每个窗口放菜的人，我在某某号桌，菜好了直接送到我桌子上就行，这样就完全避免了任何阻塞

无论在任何场景 accept ，read ,write 等都是注册一个回调函数，然后这些事件发生了自然就会回调到这些函数

AIO 优缺点：

优点：完全异步io,没有阻塞问题， 最大限度的提高并发量

缺点：需要计算机操作系统底层支持事件注册回调函数，目前来说大多数linux系统都支持注册回调，windows以及其他一些系统部分不支持，不支持的时候默认会用nio实现

AIO运行图：

AIO 案例代码：

服务端最简单示例：

创建AIO 服务端，有客户端连接后发送hello 字符串，并接受客户端reply 回复

 /**
     * @description: demos of jdk8 java.nio.AsynchronousServerSocketChannel CompletionHandler class
     * 创建AIO 服务端，有客户端连接后发送hello 字符串，并接受客户端reply 回复
     */
    @Test
    public void testAIOServer() throws IOException {
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        AsynchronousServerSocketChannel serverSocketChannel = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(8097));
        serverSocketChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
            @Override
            public void completed(AsynchronousSocketChannel asc, Object attachment) {
                byteBuffer.clear();
                byteBuffer.put("hello".getBytes());
                byteBuffer.flip();
                asc.write(byteBuffer, null, new CompletionHandler<Integer, Object>() {
                    @Override
                    public void completed(Integer result, Object attachment) {
                        byteBuffer.clear();
                    }
                    @Override
                    public void failed(Throwable exc, Object attachment) {
                    }
                });
                asc.read(byteBuffer, null, new CompletionHandler<Integer, Object>() {
                    @Override
                    public void completed(Integer result, Object attachment) {
                        byteBuffer.flip();
                        String rs = new String(byteBuffer.array());
                        System.out.println(rs);
                    }
                    @Override
                    public void failed(Throwable exc, Object attachment) {
                    }
                });
            }
            @Override
            public void failed(Throwable exc, Object attachment) {
            }
        });
        while(true) {}
    }

客户端最简单示例：

创建客户端，连接到服务端后接收到hello 字符串，并接向服务端发送reply 字符串回复

/**
     * @description: demos of jdk8 java.nio.AsynchronousSocketChannel CompletionHandler class
     * 创建客户端，连接到服务端后接收到hello 字符串，并接向服务端发送reply 字符串回复
     */
    @Test
    public void testAIOClient() throws IOException {
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        AsynchronousSocketChannel asynchronousSocketChannel = AsynchronousSocketChannel.open();
        asynchronousSocketChannel.connect(new InetSocketAddress("127.0.0.1", 8097), null, new CompletionHandler<Void, Object>() {
            @Override
            public void completed(Void result, Object attachment) {
                byteBuffer.clear();
                asynchronousSocketChannel.read(byteBuffer, null, new CompletionHandler<Integer, Object>() {
                    @Override
                    public void completed(Integer result, Object attachment) {
                        byteBuffer.flip();
                        String rs = new String(byteBuffer.array());
                        System.out.println(rs);
                        byteBuffer.clear();
                        byteBuffer.put("relpy".getBytes());
                        byteBuffer.flip();
                        asynchronousSocketChannel.write(byteBuffer);
                    }
                    @Override
                    public void failed(Throwable exc, Object attachment) {
                    }
                });
            }
            @Override
            public void failed(Throwable exc, Object attachment) {
            }
        });
        while(true) {}
    }



文章标签：
Java
Linux
Windows
关键词：
Java代码
Java案例
Java原理
Java代码案例
Java原理代码
峡谷电光马仔
目录
相关文章
༺ཌༀൢ学海无涯ൢༀད༻
|
2月前
|
存储 Java 数据处理
Java的IO技术和NIO技术
Java的IO技术和NIO技术
༺ཌༀൢ学海无涯ൢༀད༻
23 0
达芬奇要当程序员
|
2月前
|
Java API
java中IO与NIO有什么不同
java中IO与NIO有什么不同
达芬奇要当程序员
37 0
桃李春风一杯酒
|
24天前
|
监控 Java 开发者
深入理解 Java 网络编程和 NIO
【4月更文挑战第19天】Java网络编程基于Socket，但NIO（非阻塞I/O）提升了效率和性能。NIO特点是非阻塞模式、选择器机制和缓冲区，适合高并发场景。使用NIO涉及通道、选择器和事件处理，优点是高并发、资源利用率和可扩展性，但复杂度、错误处理和性能调优是挑战。开发者应根据需求选择是否使用NIO，并深入理解其原理。
桃李春风一杯酒
16 1
龙大吉
|
29天前
|
存储 监控 Java
Java输入输出：什么是NIO（New I/O）？
Java NIO是一种高效I/O库，特征包括非阻塞性操作、通道（如文件、网络连接）、缓冲区和选择器。选择器监控通道状态变化，通知应用程序数据可读写，避免轮询，提升性能。示例代码展示了一个使用NIO的服务器，监听连接、读取数据并处理客户端通信。
龙大吉
14 1
爱喝汤的技术少年
|
3月前
|
移动开发 编解码 网络协议
用Java的BIO和NIO、Netty来实现HTTP服务器(三) 用Netty实现
用Java的BIO和NIO、Netty来实现HTTP服务器(三) 用Netty实现
爱喝汤的技术少年
46 0
长梦
|
1天前
|
Java 调度
Java一分钟之线程池：ExecutorService与Future
【5月更文挑战第12天】Java并发编程中，`ExecutorService`和`Future`是关键组件，简化多线程并提供异步执行能力。`ExecutorService`是线程池接口，用于提交任务到线程池，如`ThreadPoolExecutor`和`ScheduledThreadPoolExecutor`。通过`submit()`提交任务并返回`Future`对象，可检查任务状态、获取结果或取消任务。注意处理`ExecutionException`和避免无限等待。实战示例展示了如何异步执行任务并获取结果。理解这些概念对提升并发性能至关重要。
长梦
15 5
天下无贼001
|
1天前
|
安全 Java 调度
深入理解Java并发编程：线程安全与性能优化
【5月更文挑战第12天】 在现代软件开发中，多线程编程是提升应用程序性能和响应能力的关键手段之一。特别是在Java语言中，由于其内置的跨平台线程支持，开发者可以轻松地创建和管理线程。然而，随之而来的并发问题也不容小觑。本文将探讨Java并发编程的核心概念，包括线程安全策略、锁机制以及性能优化技巧。通过实例分析与性能比较，我们旨在为读者提供一套既确保线程安全又兼顾性能的编程指导。
天下无贼001
16 8
长梦
|
1天前
|
Java
Java一分钟：线程协作：wait(), notify(), notifyAll()
【5月更文挑战第11天】本文介绍了Java多线程编程中的`wait()`, `notify()`, `notifyAll()`方法，它们用于线程间通信和同步。这些方法在`synchronized`代码块中使用，控制线程执行和资源访问。文章讨论了常见问题，如死锁、未捕获异常、同步使用错误及通知错误，并提供了生产者-消费者模型的示例代码，强调理解并正确使用这些方法对实现线程协作的重要性。
长梦
10 3
长梦
|
1天前
|
安全 算法 Java
Java一分钟：线程同步：synchronized关键字
【5月更文挑战第11天】Java中的`synchronized`关键字用于线程同步，防止竞态条件，确保数据一致性。本文介绍了其工作原理、常见问题及避免策略。同步方法和同步代码块是两种使用形式，需注意避免死锁、过度使用导致的性能影响以及理解锁的可重入性和升级降级机制。示例展示了同步方法和代码块的运用，以及如何避免死锁。正确使用`synchronized`是编写多线程安全代码的核心。
长梦
49 2
长梦
|
1天前
|
安全 Java 调度
Java一分钟：多线程编程初步：Thread类与Runnable接口
【5月更文挑战第11天】本文介绍了Java中创建线程的两种方式：继承Thread类和实现Runnable接口，并讨论了多线程编程中的常见问题，如资源浪费、线程安全、死锁和优先级问题，提出了解决策略。示例展示了线程通信的生产者-消费者模型，强调理解和掌握线程操作对编写高效并发程序的重要性。
长梦
35 3

热门文章

最新文章

  • 1
    Java Nio中的三种内存映射缓冲区---MappedByteBuffer
  • 2
    NIO通道（channel）原理与获取
  • 3
    Java NIO -- 通道 Channel
  • 4
    NIO入门系列之第二章：通道和缓冲区
  • 5
    java的nio之：java的nio系列教程之serverSocketChannel
  • 6
    NIO入门系列之第7章：文件锁定
  • 7
    NIO直接缓冲区与非直接缓冲区
  • 8
    NIO 详解 （尚硅谷 学习代码）
  • 9
    Java NIO 之 复制文件 案例
  • 10
    java的nio之：java的nio系列教程之FileChannel
  • 1
    [Java基础]——类的生命周期
    17
  • 2
    [java进阶]——泛型类、泛型方法、泛型接口、泛型的通配符
    28
  • 3
    【java进阶】Java中线程的实现方式
    24
  • 4
    【java进阶】集合的三种遍历(迭代器、增强for、Lambda)
    20
  • 5
    [java进阶]——方法引用改写Lambda表达式
    35
  • 6
    深入理解 Java 多线程、Lambda 表达式及线程安全最佳实践
    127
  • 7
    java base64转doc文件
    37
  • 8
    [JavaWeb]——过滤器filter与拦截器Interceptor的使用、执行过程、区别
    47
  • 9
    Java中的异常语法知识居然这么好玩！后悔没有早点学习
    38
  • 10
    Java必刷入门递归题×5（内附详细递归解析图）
    26

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • Python网络通信程序典型应用
  • Elasticsearch Java API Client 开发
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）