Java中BIO、NIO 和 AIO 的区别？

最新推荐文章于 2024-09-06 09:06:02 发布
最新推荐文章于 2024-09-06 09:06:02 发布
阅读量263 收藏 6
点赞数 3
分类专栏： Java面试题 文章标签： java nio python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33326733/article/details/139024226
版权

在面试中，BIO、NIO 和 AIO 是 Java IO 模型中经常被问到的知识点。理解它们之间的区别、工作原理以及应用场景，对于一个资深的 Java 开发者来说是非常重要的。

1. BIO（Blocking I/O）

BIO 模型是最传统的 Java I/O 模型，基于阻塞流的方式进行数据读写操作。每个连接都会占用一个独立的线程，当连接数量增加时，会导致线程数量急剧增加，进而影响系统性能。

工作原理：

  • 阻塞：每次读写操作都会阻塞当前线程，直到操作完成。
  • 线程消耗：每个连接需要一个独立的线程进行处理。

示例代码：

java

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class BIOServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("BIO Server started, listening on port 8080");

        while (true) {
            // 阻塞等待客户端连接
            Socket socket = serverSocket.accept();
            new Thread(new ClientHandler(socket)).start();
        }
    }
}

class ClientHandler implements Runnable {
    private Socket socket;

    public ClientHandler(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            // 读/写操作
            InputStream input = socket.getInputStream();
            OutputStream output = socket.getOutputStream();
            byte[] buffer = new byte[1024];
            int bytesRead;
            while ((bytesRead = input.read(buffer)) != -1) {
                output.write(buffer, 0, bytesRead);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

适用场景：

  • 连接数较少且固定
  • 应用对响应时间要求不高
  • 开发简单的应用
2. NIO（Non-blocking I/O）

NIO 模型引入了非阻塞 IO 操作，通过选择器（Selector）管理多个通道（Channel），实现高效地处理大量连接。NIO 提供了缓冲区（Buffer）和选择器（Selector）等重要概念。

工作原理：

  • 非阻塞：读写操作不会阻塞，通道可以在准备好时进行数据传输。
  • 选择器：通过一个线程管理多个通道，减少线程消耗。

示例代码：

java

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class NIOServer {
    public static void main(String[] args) throws IOException {
        Selector selector = Selector.open();
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(8080));
        serverSocketChannel.configureBlocking(false);
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("NIO Server started, listening on port 8080");

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

                if (key.isAcceptable()) {
                    handleAccept(key);
                } else if (key.isReadable()) {
                    handleRead(key);
                }
            }
        }
    }

    private static void handleAccept(SelectionKey key) throws IOException {
        ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
        SocketChannel socketChannel = serverSocketChannel.accept();
        socketChannel.configureBlocking(false);
        socketChannel.register(key.selector(), SelectionKey.OP_READ);
    }

    private static void handleRead(SelectionKey key) throws IOException {
        SocketChannel socketChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int bytesRead = socketChannel.read(buffer);
        if (bytesRead > 0) {
            buffer.flip();
            socketChannel.write(buffer);
        } else if (bytesRead == -1) {
            socketChannel.close();
        }
    }
}

适用场景：

  • 连接数较多的应用
  • 对响应时间要求较高
  • 高并发场景
3. AIO（Asynchronous I/O）

AIO 模型是 JDK 7 引入的一种异步 IO 模型，提供了异步通道（AsynchronousSocketChannel）和异步文件通道（AsynchronousFileChannel）。AIO 模型可以在操作完成时通过回调函数通知应用程序，从而实现更高效的 IO 操作。

工作原理：

  • 异步：读写操作不阻塞，操作完成后通过回调函数通知。
  • 回调机制：通过 CompletionHandler 接口实现回调机制。

示例代码：

java

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.CountDownLatch;

public class AIOServer {
    public static void main(String[] args) throws IOException {
        AsynchronousServerSocketChannel serverSocketChannel = AsynchronousServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(8080));
        System.out.println("AIO Server started, listening on port 8080");

        CountDownLatch latch = new CountDownLatch(1);
        serverSocketChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
            @Override
            public void completed(AsynchronousSocketChannel result, Object attachment) {
                serverSocketChannel.accept(null, this);
                handleClient(result);
            }

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

        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static void handleClient(AsynchronousSocketChannel channel) {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        channel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                attachment.flip();
                channel.write(attachment, attachment, new CompletionHandler<Integer, ByteBuffer>() {
                    @Override
                    public void completed(Integer result, ByteBuffer attachment) {
                        attachment.clear();
                        channel.read(attachment, attachment, this);
                    }

                    @Override
                    public void failed(Throwable exc, ByteBuffer attachment) {
                        exc.printStackTrace();
                        try {
                            channel.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }

            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                exc.printStackTrace();
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

适用场景：

  • 高并发、低延迟的应用
  • 需要异步处理的场景
  • 性能至关重要的系统

总结

  • BIO：简单易用，适用于连接数较少的场景，但线程开销较大。
  • NIO：通过非阻塞和选择器机制，适用于高并发场景，但开发复杂度较高。
  • AIO：通过异步和回调机制，适用于高并发和低延迟的场景，但需要 JDK 7 及以上版本。

通过理解 BIO、NIO 和 AIO 的工作原理和应用场景，开发者可以根据具体需求选择合适的 IO 模型，从而优化系统性能和提高开发效率。

qq_33326733
关注
专栏目录
Java AIO
JustinMars的博客
08-04 529
Java AIO
Java的IO流 ，BIO NIO AIO 的区别？
qq_45071235的博客
03-19 573
目录 1.在了解不同的IO之前先了解：同步与异步，阻塞与非阻塞的区别: 2.BIO NIO AIO 分别代表什么？（面试简答）： 3.BIO和NIO、AIO的区别: 4.java中io流的分类： • FileInputStream（按照字节输入） • FileOutputStream（按照字节输出） • FileReader(字符输入) • FileWriter（字符输出） • 节点流与处理流 节点流和处理流的区别和联系 ： • BufferedReader/Buff...
java中的AIO
weixin_34406061的博客
11-30 583
简介 jdk7中新增了一些与文件(网络)I/O相关的一些api。这些API被称为NIO.2，或称为AIO(Asynchronous I/O)。AIO最大的一个特性就是异步能力，这种能力对socket与文件I/O都起作用。AIO其实是一种在读写操作结束之前允许进行其他操作的I/O处理。AIO是对JDK1.4中提出的同步非阻塞I/O(NIO)...
java当中什么是AIO
最新发布
Flying_Fish_roe的博客
09-06 791
AIO，全称为Asynchronous IO（异步输入输出），是Java中的一种处理I/O操作的方式，尤其在处理高并发、大量I/O请求时非常有效。AIO是Java NIO.2的一部分，是Java 7中引入的，用于改进NIO（Non-blocking IO，非阻塞输入输出）中的一些局限性。
Java BIO、NIO、AIO 有什么区别？
sanmansan的博客
01-05 415
Java BIO、NIO、AIO 有什么区别？
java AIO学习
weixin_30430169的博客
09-21 234
转载Reactor and Proactor的内容 系统I/O 可分为阻塞型, 非阻塞同步型以及非阻塞异步型[1,2]. 阻塞型I/O意味着控制权只到调用操作结束了才会回到调用者手里. 结果调用者被阻塞了, 这段时间了做不了任何其它事情. 更郁闷的是,在等待IO结果的时间里,调用者所在线程此时无法腾出手来去响应其它的请求，这真是太浪费资源了。拿read()操作来说吧, 调用...
java aio_【Java】Java AIO使用
weixin_32973973的博客
02-12 379
欢迎关注公众号: nullobject 。文章首发在个人博客 https://www.nullobject.cn，公众号nullobject同步更新。这篇文章主要介绍Java AIO网络编程。1. AIO是什么本文所说的AIO特指Java环境下的AIO。AIO是java中IO模型的一种，作为NIO的改进和增强随JDK1.7版本更新被集成在JDK的nio包中，因此AIO也被称作是NIO2.0。区别于...
浅谈Java中BIO、NIO和AIO的区别和应用场景
08-26
Java中BIO、NIO和AIO的区别和应用场景 Java中IO模型有三种：BIO、NIO和AIO，下面我们来详细介绍它们的区别和应用场景。 BIO（Blocking I/O） BIO是Java中最古老的IO模型，它是同步并阻塞的。服务器的实现模式是一...
Java后端面试高频问题：BIO、NIO、AIO的区别？
weixin_70730532的博客
07-07 4395
①BIO（blocking IO）阻塞IO，即在读写数据的过程中会发生阻塞现象。当用户线程发出IO请求之后，内核会去查看数据是否就绪，如果没有就绪就会等待数据就绪，而用户线程就会处于阻塞状态，用户线程交出CPU。当数据就绪之后，操作系统就会将数据从内核空间拷贝到用户空间，并返回结果给用户线程，用户线程才解除阻塞状态。（因为我们的用户程序只能获取用户空间的内存，无法直接获取内核空间的内存）典型的阻塞IO模型的例子为：data = socket.read();如果数据没有就绪，就会一直阻塞在read方法。 ②N
基于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中BIO、NIO、AIO是三个不同的IO模型，它们之间的区别在于同步和异步，阻塞和非阻塞。理解这些概念对于设计高性能的IO体系非常重要。
java aio 编程
qq_26847293的博客
03-23 384
Java NIO (JSR 51)定义了Java new I/O API，提案2000年提出,2002年正式发布。 JDK 1.4起包含了相应的API实现。 JAVA NIO2 (JSR 203)定义了更多的 New I/O APIs， 提案2003提出，直到2011年才发布， 最终在JDK 7中才实现。 JSR 203除了提供更多的文件系统操作API(包括可插拔的自定义的文件系统)， 还提供了
JAVA AIO
chengqing3485的博客
07-16 204
AIO 与NIO不同，当进行读写操作时，只须直接调用API的read或write方法即可。这两种方法均为异步的，对于读操作而言，当有流可读取时，操作系统会将可读的流传入read方法的缓冲区，并通知应用程序；对于写操作而言，当操作系统将write方法传递的流写入完毕时，操作系统主动通...
java aio_java中的AIO
weixin_39571179的博客
02-16 146
简介jdk7中新增了一些与文件(网络)I/O相关的一些api。这些API被称为NIO.2，或称为AIO(Asynchronous I/O)。AIO最大的一个特性就是异步能力，这种能力对socket与文件I/O都起作用。AIO其实是一种在读写操作结束之前允许进行其他操作的I/O处理。AIO是对JDK1.4中提出的同步非阻塞I/O(NIO)的进一步增强。关于NIO,之前的一篇文章可以看看：java中的...
java aio_JavaAIO编程
weixin_29306011的博客
02-19 194
Asynchronous IO： 异步非阻塞的编程方式与 NIO 不同，当进行读写操作时，只须直接调用 API 的 read 或 write 方法即可。这两种 方法均为异步的，对于读操作而言，当有流可读取时，操作系统会将可读的流传入 read 方 法的缓冲区，并通知应用程序；对于写操作而言，当操作系统将 write 方法传递的流写入完 毕时，操作系统主动通知应用程序。即可以理解为，read/wri...
Java中单个对象内存图解析
gkkljy的博客
12-13 288
执行下图代码，执行过程中内存解析 内存共分为三块，栈、堆、方法区 首先，会将类的字节码文件加载进方法区，但是有两个类，谁先加载呢，肯定是带main方法的类先加载，main方法里含有程序的入口，TestStudent类中只有一个主方法，所以主方法也会加载进方法区，同时，主方法会被虚拟机自动调用执行，加载进栈内存 然后主方法声明了一个Student类型的对象，但方法区此时没有Student类，所以会把Student类字节码文件加载进方法区，同时将该类的成员变量和成员方法都加载进方法区 使用new创建对象，
Java-AIO
Shawn Jeon`s blog
02-27 223
Java AIOAIO概述Path接口Paths工具类Files工具类使用例子 AIO概述 AIO(Asynchronous IO)是 Java 1.7之后引入的包. 特点是异步非阻塞, 属 NIO的扩展, 又称 NIO.2 主要新增 Path接口, Paths和 Files工具类 Path接口 java.nio.file.Path代表一个平台无关的路径, 表示目录结构和指定文件的位置 常用方法: 方法 说明 boolean isAbsolute() 判断是否为绝对路径 Path
JAVA AIO编程
bo123_的博客
04-25 1132
AIO 异步非阻塞的编程方式 进行读写操作的时候，只需要调用api的read和write方法即可，这两种方法均为异步的。对于读操作而言，当有流可读取的时候，操作系统会将可读的流传入read方法的缓存区，并通知应用；对于写操作而言，当操作系统将write方法传递的流写入完毕，操作系统通知应用程序。可以理解为read/write方法是异步的，完成后主动回调函数。 异步非阻塞，服务器实现模式为一个有效请...
java中BIO,NIO,AIO 有什么区别?
05-11
BIO、NIO、AIO 是 Java 中用于网络编程的三种不同的 I/O 模型。 1. BIO (Blocking I/O)：同步阻塞 I/O 模型。在这种模型下，当用户线程发起一个 I/O 操作时，内核会一直等待，直到数据返回才会返回给用户线程。这种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值