五种io模型对比以及使用场景，提供java demo

于 2023-12-22 14:47:52 发布
阅读量1.1k 收藏 22
点赞数 37
分类专栏： 多线程 java 计算机网络 文章标签： java 开发语言 多线程 后端 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44808225/article/details/135152805
版权
java 同时被 3 个专栏收录
67 篇文章 0 订阅
订阅专栏
计算机网络
11 篇文章 0 订阅
订阅专栏
多线程
5 篇文章 0 订阅
订阅专栏

标题：对比各种 I/O 方式及其使用场景

在计算机编程中，I/O（输入/输出）操作是非常常见的，它涉及到程序与外部设备（如磁盘、网络、键盘、显示器等）之间的数据交换。随着计算机技术的发展，出现了多种 I/O 方式，每种方式都有其特点、优势和劣势。本文将对比目前为止的各种 I/O 方式，包括阻塞 I/O、非阻塞 I/O、I/O 多路复用、信号驱动 I/O、异步 I/O 等，并给出它们的使用场景和一个 Java 的使用例子。

对比各种 I/O 方式

下表对比了各种 I/O 方式的特点、优势、劣势和使用场景：

I/O 方式特点优势劣势使用场景
阻塞 I/O调用会一直阻塞直到有数据返回简单易用、适合顺序读写性能较差、无法满足并发需求适用于顺序读写、数据量小的情况
非阻塞 I/O调用不会阻塞，但需要轮询检查状态灵活，可以处理多个连接需要不断轮询状态，性能较差适用于需要处理多个连接的情况
I/O 多路复用通过 select/poll/epoll 等系统调用可以同时处理多个连接、高效需要对文件描述符进行复杂的管理、编程复杂适用于需要高并发处理的情况
信号驱动 I/O通过信号通知 I/O 完成简化了状态轮询、适合处理信号驱动的 I/O对信号处理要求高、编程复杂适用于需要对 I/O 事件进行信号驱动处理的情况
异步 I/O调用会立即返回，通过回调函数通知完成高效、适合大规模并发、适合处理大文件编程复杂、不适合处理小数据量、不适合顺序读写适用于需要高效处理大规模并发、大文件的情况

例子（java）

BIO

当使用阻塞式 I/O（BIO）时，通常会使用 Socket 和 ServerSocket 来进行网络通信。以下是一个简单的 Java
示例，其中包含一个使用 BIO 的客户端和服务器端。

服务端代码：
import java.io.*;
import java.net.*;

public class SimpleServer {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8080);
            System.out.println("Server started, waiting for client...");

            Socket clientSocket = serverSocket.accept();
            System.out.println("Client connected: " + clientSocket);

            BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
            PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);

            String inputLine;
            while ((inputLine = in.readLine()) != null) {
                System.out.println("Received from client: " + inputLine);
                out.println("Server received: " + inputLine);
            }

            clientSocket.close();
            serverSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
客户端代码：
import java.io.*;
import java.net.*;

public class SimpleClient {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 8080);
            PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
            BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));

            out.println("Hello, server!");
            System.out.println("Server response: " + in.readLine());

            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，服务端通过 ServerSocket 监听端口，当有客户端连接时，通过 accept() 方法接受连接。客户端通过
Socket 连接到服务端，并发送消息。服务端接收到消息后，发送回应，并关闭连接。这是一个简单的使用阻塞式 I/O
的客户端-服务器端通信例子。

NIO
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousFileChannel;
import java.nio.channels.CompletionHandler;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;

public class FileCopyExample {
    public static void main(String[] args) {
        try {
            AsynchronousFileChannel sourceChannel = AsynchronousFileChannel.open(Paths.get("source.txt"), StandardOpenOption.READ);
            AsynchronousFileChannel destinationChannel = AsynchronousFileChannel.open(Paths.get("destination.txt"), StandardOpenOption.WRITE, StandardOpenOption.CREATE);

            ByteBuffer buffer = ByteBuffer.allocate(1024);

            sourceChannel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                @Override
                public void completed(Integer result, ByteBuffer attachment) {
                    attachment.flip();
                    destinationChannel.write(attachment, 0, attachment, new CompletionHandler<Integer, ByteBuffer>() {
                        @Override
                        public void completed(Integer result, ByteBuffer buffer) {
                            if (buffer.hasRemaining()) {
                                destinationChannel.write(buffer, 0, buffer, this);
                            } else {
                                System.out.println("File copy completed");
                            }
                        }

                        @Override
                        public void failed(Throwable exc, ByteBuffer attachment) {
                            System.out.println("File copy failed: " + exc.getMessage());
                        }
                    });
                }

                @Override
                public void failed(Throwable exc, ByteBuffer attachment) {
                    System.out.println("File read failed: " + exc.getMessage());
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在上述示例中，我们使用了 Java 的异步 I/O（NIO）API 来实现文件的异步复制操作。通过异步
I/O，可以高效地处理大文件复制操作，而不会阻塞主线程。

AIO

在 Java 中，可以使用 AsynchronousServerSocketChannel 和
AsynchronousSocketChannel 类来实现基于 AIO（Asynchronous
I/O）的网络通信。以下是一个简单的使用 AIO 的服务器端和客户端的示例代码。

服务端代码：
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.ExecutionException;

public class SimpleAioServer {
    public static void main(String[] args) throws IOException, ExecutionException, InterruptedException {
        AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(8080));
        System.out.println("Server started, waiting for client...");

        server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
            @Override
            public void completed(AsynchronousSocketChannel client, Void attachment) {
                server.accept(null, this); // 接受下一个连接

                handleClient(client);
            }

            @Override
            public void failed(Throwable exc, Void attachment) {
                // 处理错误
            }
        });

        // 保持服务器运行
        Thread.sleep(10000);
    }

    private static void handleClient(AsynchronousSocketChannel client) {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        client.read(buffer, null, new CompletionHandler<Integer, Void>() {
            @Override
            public void completed(Integer result, Void attachment) {
                if (result == -1) {
                    try {
                        client.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    return;
                }

                buffer.flip();
                byte[] data = new byte[buffer.limit()];
                buffer.get(data);
                System.out.println("Received from client: " + new String(data));

                buffer.flip();
                client.write(buffer, null, new CompletionHandler<Integer, Void>() {
                    @Override
                    public void completed(Integer result, Void attachment) {
                        if (buffer.hasRemaining()) {
                            client.write(buffer, null, this);
                        } else {
                            buffer.clear();
                            client.read(buffer, null, this);
                        }
                    }

                    @Override
                    public void failed(Throwable exc, Void attachment) {
                        // 处理错误
                    }
                });
            }

            @Override
            public void failed(Throwable exc, Void attachment) {
                // 处理错误
            }
        });
    }
}
客户端代码：
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.ExecutionException;

public class SimpleAioClient {
    public static void main(String[] args) throws IOException, ExecutionException, InterruptedException {
        AsynchronousSocketChannel client = AsynchronousSocketChannel.open();
        client.connect(new InetSocketAddress("localhost", 8080), null, new CompletionHandler<Void, Void>() {
            @Override
            public void completed(Void result, Void attachment) {
                try {
                    client.write(ByteBuffer.wrap("Hello, server!".getBytes())).get();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    client.read(buffer, null, new CompletionHandler<Integer, Void>() {
                        @Override
                        public void completed(Integer result, Void attachment) {
                            buffer.flip();
                            byte[] data = new byte[buffer.limit()];
                            buffer.get(data);
                            System.out.println("Server response: " + new String(data));
                            try {
                                client.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }

                        @Override
                        public void failed(Throwable exc, Void attachment) {
                            // 处理错误
                        }
                    });
                } catch (InterruptedException | ExecutionException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void failed(Throwable exc, Void attachment) {
                // 处理错误
            }
        });

        // 保持客户端运行
        Thread.sleep(5000);
    }
}

在这个例子中，服务端和客户端都使用了 AIO 的方式来进行异步的网络通信。服务端通过
AsynchronousServerSocketChannel 接受连接，并在连接建立后处理客户端的请求。客户端通过
AsynchronousSocketChannel 连接到服务端，并发送消息，然后接收服务端的响应。

开源项目

以下是一些常见的开源组件和框架，它们使用了不同的 I/O 模型：

  1. Nginx：使用事件驱动的 I/O 多路复用模型，通过 epoll 或 kqueue 实现高并发的网络通信。
  2. Node.js：使用非阻塞 I/O 模型和事件驱动架构，基于 JavaScript 运行时环境实现高性能的 I/O 操作。
  3. Netty：一个基于 Java NIO 的异步事件驱动的网络应用框架，适用于快速开发高性能的网络通信程序。
  4. Apache MINA：一个基于 Java NIO 的网络应用框架，提供了高性能的网络通信解决方案。
  5. libuv：一个跨平台的异步 I/O 库，最初由 Node.js 使用，后来也被其他项目采用。
  6. Redis：使用多路复用模型和非阻塞 I/O，实现高性能的内存数据库服务。
  7. Kafka：使用了多路复用模型和异步 I/O，为分布式流处理平台提供了高吞吐量的消息传递功能。

结论

不同的 I/O 方式各有其特点和适用场景。在实际应用中，需要根据具体的需求和系统设计来选择合适的 I/O 方式。希望本文的对比能够帮助读者更好地理解各种 I/O 方式及其使用场景。

[奸笑]这个不是斜眼笑[奸笑]
关注
  • 37
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java编程中的IO模型详解：BIO，NIO，AIO的区别与实际应用场景分析
01-04
IO模型决定了数据的传输方式，Java支持BIO，NIO，AIO三种IO模型。BIO是同步阻塞模型，特点是一对一的客户端与处理线程关系，适用场景是连接数量较小并且固定的，优点是编程简单，但对服务器资源要求高。NIO是同步非阻塞模型，它借助selector能以一对多的方式处理连接，优点是连接数目较多且短的场景下效率较高，如聊天服务器，服务器间通信等，但编程相对复杂。AIO则是异步非阻塞模型，它由操作系统完成后回调通知服务端程序启动线程去处理，适用于连接较多且连接时间较长的应用。这三种模式各有优劣，应根据实际情况和需求选择合适的模型。
JavaNIO浅析IO模型Java开发Java经验技巧共1
11-22
JavaNIO浅析IO模型Java开发Java经验技巧共10页.pdf.zip
Java三种IO模型原理实例详解
08-19
主要介绍了Java三种IO模型原理实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Linux 下的五种 IO 模型详细介绍
09-15
主要介绍了Linux 下的五种 IO 模型详细介绍的相关资料,需要的朋友可以参考下
哪5种IO模型？什么是select/poll/epoll？同步异步阻塞非阻塞有啥区别？全在这讲明白了！
JohnYang's CSDN Home
09-23 970
系统中有哪5种IO模型？什么是 select/poll/epoll？同步异步阻塞非阻塞有啥区别？ 本文地址http://yangjianyong.cn/?p=84转载无需经过作者本人授权 先解开第一个疑惑：有哪五种I/O模型 - Blocking I/O【阻塞I/O】 - NonBlocking I/O【非阻塞I/O】 - Multiplexing I/O【I/O多路复用】 - Asynchronous IO【异步I/O】 - Signal Driven IO【信号驱动I/O】 这些IO模型具体是怎么工作的
高级IO详解——五种IO模型
waywt1的博客
09-19 771
任何的IO过程中，都包含两个步骤，等待数据与拷贝数据。而且在实际的应用场景中，等待消耗的时间往往都远高于拷贝的时间。让IO更高效，最核心的办法就是让等待的时间尽量少。所以，高效的IO本质就是，减少单位时间内，”等“的比重。
IO模型 | 常见的五种IO模型介绍
quwenjing_blog
11-19 4016
常见IO模型 对于一次 IO 访问，它会经历两个阶段：等待数据准备就绪 (Waiting for the data to be ready)；将数据从内核拷贝到进程中 (Copying the data from the kernel to the process)。 举例来说： 读函数：分为等待系统可读和真正的读。 写函数：分为等待网卡可以写和真正的写。 说明： 等待就绪的阻塞是不使用 CPU 的，是在“空等”。而真正的读写操作的阻塞是使用 CPU 的，真正在“干活”，而且这个过程非常快，属于
一次搞清五种 I/O 模型（生动形象版）
盛夏温暖流年
12-29 939
1.阻塞IO模型是在读写数据过程中会发生阻塞现象。用户线程发出IO请求后，内核会查看数据是否就绪，如果没有就等待，而用户线程就会处于阻塞状态。当就绪后，内核会将数据拷贝到用户线程并返回结果，用户线程才解除block状态。 说人话版本 你说我要炸鸡（用户线程发出IO请求），服务小姐姐去看看炸鸡好了没（内核查看数据是否就绪），没有的话就等着炸鸡炸好（等待数据就绪），你就站那儿不敢再问悄悄等着你的鸡，服务小姐姐就去····
五种IO模型详解
八百标兵奔北坡的博客
09-04 5765
五种I/O模型详细讲解前言I/O的本质阻塞IO模型非阻塞IO模型多路复用IO模型selectpollepoll信号驱动IO模型异步IO模型总结 前言 I/O的本质 网络IO的本质就是socket流的读取，通常一次IO读取会涉及两个阶段与两个对象，其中两个对象为：用户进程（线程）Process（Thread）、内核对象（kernel）,两个阶段为：等待流数据准备阶段、从内核向进程复制数据阶段。 对于socket而言，第一步通常等待网络上的数据分组到达，然后被复制到内核的某个缓冲区，第二步数据从内核的缓冲区复制
5种I/O模型
qq_44836676的博客
05-09 1万+
IO
windows socket 五种IO模型-代码全攻略
03-23
windows socket 五种IO模型-代码全攻略
GPIO输入输出各种模式（推挽、开漏、准双向端口）详解
热门推荐
技术交流是便宜的的博客
05-20 15万+
技术交流是便宜的博客地址：http://blog.csdn.net/techexchangeischeap 概述 能将处理器的GPIO（General Purpose Input and Output）内部结构和各种模式彻底弄清楚的人并不多，最近在百度上搜索了大量关于这部分的资料，对于其中很多问题的说法并不统一。本文尽可能的将IO涉及到的所有问题罗列出来，对于有明确答案的问题解释清楚，对于还存
STM32 GPIO八种输入输出模式的功能及区别
起舞的风的博客
11-26 6129
一、GPIO八种输入输出模式 （1） GPIO_Mode_AIN 模拟输入 （2） GPIO_Mode_IN_FLOATING 浮空输入 （3） GPIO_Mode_IPD 下拉输入 （4） GPIO_Mode_IPU 上拉输入 （5） GPIO_Mode_Out_OD 开漏输出 （6） GPIO_Mode_Out_PP 推挽输出 （7） GPIO_Mode_AF_OD 复用开漏输出 （8） GP...
linux 高并发之IO多路复用select、poll和epoll的区别
ZJE
12-30 1462
一、什么是IO多路复用 文件描述符(fd) 表示的是对某个文件操作的句柄。当然socket套接字也算是fd。一般来说，想对fd进行读写操作，就要操作到fd，例如 read()，但read()本身是BIO，即阻塞IO，当对fd调用read()时，如果暂时没有数据输入到fd，那么read()将会处于阻塞状态，直到有数据输入，read()才会返回。 那么我们就可以想，如果现在有一个客户端连接进服务器，想要跟服务端通信，那么服务端就 对表示这个服务器的 sd(socket也能当作fd)，调用read()，此时，
五种IO模型（详解+形象例子说明）
ZWE7616175的博客
06-06 4万+
在网络环境下，通俗的讲，将IO分为两步： 1.等； 2.数据搬迁。 如果要想提高IO效率，需要将等的时间降低。 五种IO模型包括：阻塞IO、非阻塞IO、信号驱动IO、IO多路转接、异步IO。其中，前四个被称为同步IO。 在介绍五种IO模型时，我会举生活中钓鱼的例子，加深理解。 1.阻塞IO（blocking I/O） A拿着一支鱼竿在河边钓鱼，并且一直在鱼竿前等，在等的时候不做其...
五种IO模型：操作系统五种IO模型大全
緑水長流*z
05-10 9万+
包含操作系统的应用与内核，CPU指令等级，内核空间、用户空间，内核态与用户态；网络IO，磁盘IO，内存IO，异步/同步IO，阻塞/非阻塞IO，以及操作系统的五种IO模型，阻塞IO，非阻塞IO，复用IO（select、poll、epoll）、信号驱动IO模型，异步IO模型等...
linux五种IO模型
bobozai86的博客
03-27 4102
为了更好的理解五种IO模型，我们先来说一下几个概念：同步，异步，阻塞和非阻塞。 同步和异步 　　这两个概念与消息的通知机制有关。 同步 　　所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回。比如，调用readfrom系统调用时，必须等待IO操作完成才返回。 异步 　　异步的概念和同步相对。当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态、通知和回调来通知调用者。比如：调用aio_read系统调用时，不必等IO操作完成就直接返回，调用
聊聊linux 五种io模型,深入聊聊Linux 五种IO模型
weixin_42413455的博客
05-14 99
一般聊到所线程或者并发网络上面的知识面试官都会延伸到此知识点哦！！！一、相关概念讲解1、同步与异步同步就是一个任务的完成需要依赖另外一个任务时，只有等待被依赖的任务完成后，依赖的任务才能算完成，这是一种可靠的任务序列。要么成功都成功，失败都失败，两个任务的状态可以保持一致。异步是不需要等待被依赖的任务完成，只是通知被依赖的任务要完成什么工作，依赖的任务也立即执行，只要自己完成了整个任务就算完成了。...
举例 Java IO的使用场景及代码
最新发布
09-27
Java IO的使用场景可以涵盖从文件读写到网络数据流的操作，比如说从本地文件中读取数据到内存，或者从网络中读取文件到本地。以下是一个简单的示例代码，演示了如何使用Java IO从本地文件中读取数据：import java.io.FileReader; import java.io.BufferedReader;public class ReadFileExample { public static void main(String[] args) { try { FileReader reader = new FileReader("example.txt"); BufferedReader bufferedReader = new BufferedReader(reader); String line; while ((line = bufferedReader.readLine()) != null) { System.out.println(line); } reader.close(); } catch (Exception e) { e.printStackTrace(); } } }

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值