Java详解之I/O[BIO、NIO、AIO使用方法和示范代码]

已于 2023-11-21 14:19:49 修改
阅读量370 收藏 5
点赞数
文章标签： java 开发语言
于 2023-11-21 10:17:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/goTsHgo/article/details/134523748
版权

前言：

小弟能力不足，认知有限，难免考虑不全面，希望大佬能给出更好的建议，指出存在的问题和不足，在此跪谢。

IO发展史

Java中对于I/O能力的支持主要分为三个比较关键的阶段：

BIO

第一个阶段是起步阶段JDK1.0 ~ JDK1.3,这个阶段JDK是处于BIO阶段的，也就是同步阻塞模式，该阶段的类库还非常的初级，对系统层面的一些网络编程的API都没有进行实现，因此这个阶段的很多大型应用服务器都采用C或者C++语言来进行开发的，因为C或者C++可以直接调用操作系统提供的非阻塞I/O能力；

NIO

第二个阶段从JDK1.4开始的，从JDK1.4开始，Java新增了java.nio的包，正式支持的NIO，提供了许多非阻塞I/O开发的API和类库；

AIO

第三个阶段是从JDK1.7开始的，这一次是对原来的NIO类库进行了升级，官方称为NIO 2.0，该版本不但强化了原来的基于I/O多路复用模型的NIO模式，同时新增了异步的AIO功能，所以也有很多人称之为AIO。

各个IO介绍

BIO

在Java中，BIO（Blocking I/O）指的是阻塞式I/O，是一种基本的I/O模型。它的实现原理相对简单，但在高并发场景下性能较差。下面我将详细介绍BIO的实现原理。

  1. 阻塞式I/O：
    在BIO中，当一个线程在进行I/O操作时，如果数据没有准备好，该线程会被阻塞，直到数据准备好并被读取或写入。这意味着一个线程只能处理一个连接，如果有大量连接同时到来，就需要大量线程来处理，这会导致资源消耗过大。

  2. 实现原理：

    • 服务端：服务端通过ServerSocket监听客户端的连接请求。当有连接请求到来时，服务端会创建一个新的线程来处理该连接。
    • 客户端：客户端通过Socket向服务端发起连接请求。一旦连接建立，客户端和服务端之间可以进行数据的读取和写入。

  3. 服务端示例代码：

    思路：在服务端的代码中，我们创建了一个固定大小的线程池，用于处理客户端的连接请求。每当有客户端连接时，就会将连接交给线程池中的一个线程来处理，这样可以提高并发处理能力。同时，我们定义了一个ClientHandler类来处理客户端的请求，这样可以更好地组织代码逻辑。

    这样的设计可以更好地满足企业级生产环境的要求，提高了系统的并发处理能力和稳定性。当然你还可以加入日志打印，更好的排查问题，但是因为这种已经过时，所以只是简单示例。

    import java.io.*;
import java.net.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class Server {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        ExecutorService executor = Executors.newFixedThreadPool(10); // 创建一个固定大小的线程池

        try {
            serverSocket = new ServerSocket(8080);
            System.out.println("Server started. Waiting for client...");

            while (true) {
                // 等待客户端连接
                Socket clientSocket = serverSocket.accept();
                System.out.println("Client connected: " + clientSocket.getRemoteSocketAddress());

                // 使用线程池处理客户端请求
                executor.execute(new ClientHandler(clientSocket));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (serverSocket != null) {
                    serverSocket.close();
                }
                executor.shutdown(); // 关闭线程池
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static class ClientHandler implements Runnable {
        private Socket clientSocket;

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

        @Override
        public void run() {
            try {
                // 获取输入流
                BufferedReader input = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
                // 获取输出流
                PrintWriter output = new PrintWriter(clientSocket.getOutputStream(), true);

                // 读取客户端发送的数据
                String clientMessage = input.readLine();
                System.out.println("Received from client: " + clientMessage);

                // 向客户端发送数据
                output.println("Hello, client!");

                // 关闭流和连接
                input.close();
                output.close();
                clientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

  4. 客户端实例代码实现：

    import java.io.*;
import java.net.*;

public class Client {
    public static void main(String[] args) {
        Socket socket = null;
        try {
            socket = new Socket("localhost", 8080);
            System.out.println("Connected to server.");

            // 获取输入流
            BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            // 获取输出流
            PrintWriter output = new PrintWriter(socket.getOutputStream(), true);

            // 向服务端发送数据
            output.println("Hello, server!");

            // 读取服务端发送的数据
            String serverMessage = input.readLine();
            System.out.println("Received from server: " + serverMessage);

            // 关闭流和连接
            input.close();
            output.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (socket != null) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

  5. 适用场景：
    BIO适用于连接数较少且吞吐量要求不高的场景，例如传统的Socket通信应用。

  6. 局限性：
    由于BIO的阻塞特性，它在高并发场景下表现较差，因为大量线程会因为I/O阻塞而处于等待状态，导致资源浪费。

总的来说，BIO是一种简单直观的I/O模型，但在高并发场景下存在性能瓶颈。随着业务的发展，通常会选择更高效的NIO（Non-blocking I/O）或者AIO（Asynchronous I/O）来替代BIO。

NIO

在Java中，NIO（New I/O）是一种非阻塞I/O模型，相比于传统的BIO（Blocking I/O），NIO具有更高的并发处理能力。下面我将详细介绍NIO的实现原理。

  1. 非阻塞I/O：
    NIO的核心是非阻塞I/O，它允许一个线程处理多个连接，当一个连接上的I/O操作不可立即完成时，线程可以去处理其他连接，而不是被阻塞。

  2. 核心组件：

    • 通道（Channel）：用于读取和写入数据，可以是文件、套接字等。
    • 缓冲区（Buffer）：用于临时存储数据，读取数据到缓冲区或将缓冲区中的数据写入通道。
    • 选择器（Selector）：用于监听多个通道的事件，例如连接就绪、读就绪、写就绪等。

  3. 实现原理：

    • 服务端：服务端通过ServerSocketChannel监听连接请求，一旦有连接到来，会将该连接注册到Selector上，并监听连接就绪事件。
    • 客户端：客户端通过SocketChannel向服务端发起连接请求，连接建立后也会注册到Selector上。

  4. NIO服务器端示例代码：
    实现思路：

    在以下代码中，我们引入了日志打印服务，使用了Java自带的Logger类来记录日志。同时，我们使用了线程池来处理客户端的连接请求和数据读写操作，以提高并发处理能力。对于各种可能遇到的问题，比如连接超时、网络异常、数据读写异常等，我们在相应的位置进行了异常处理，并记录了相应的日志，以便于排查和解决问题。

    这样的设计更加符合企业级生产规范，提高了系统的并发处理能力和稳定性，并且对各种异常情况进行了处理，使得系统更加健壮可靠。

    import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Logger;

public class NIOServer {
    private static final Logger logger = Logger.getLogger(NIOServer.class.getName());
    private static final ExecutorService executor = Executors.newFixedThreadPool(10);

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

            while (true) {
                selector.select();
                Set<SelectionKey> selectedKeys = selector.selectedKeys();
                Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

                while (keyIterator.hasNext()) {
                    SelectionKey key = keyIterator.next();
                    keyIterator.remove();

                    if (key.isAcceptable()) {
                        executor.execute(() -> handleAccept(key, selector));
                    } else if (key.isReadable()) {
                        executor.execute(() -> handleRead(key));
                    }
                }
            }
        } catch (IOException e) {
            logger.severe("Error in NIO server: " + e.getMessage());
        }
    }

    private static void handleAccept(SelectionKey key, Selector selector) {
        try {
            ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
            SocketChannel clientChannel = serverSocketChannel.accept();
            clientChannel.configureBlocking(false);
            clientChannel.register(selector, SelectionKey.OP_READ);
        } catch (IOException e) {
            logger.severe("Error in handleAccept: " + e.getMessage());
        }
    }

    private static void handleRead(SelectionKey key) {
        try {
            SocketChannel clientChannel = (SocketChannel) key.channel();
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int bytesRead = clientChannel.read(buffer);
            if (bytesRead == -1) {
                clientChannel.close();
                key.cancel();
            } else if (bytesRead > 0) {
                buffer.flip();
                byte[] data = new byte[bytesRead];
                buffer.get(data);
                logger.info("Received from client: " + new String(data));
                // 可以在这里处理接收到的数据
            }
        } catch (IOException e) {
            logger.severe("Error in handleRead: " + e.getMessage());
        }
    }
}

  5. NIO客户端的代码：

    import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Logger;

public class NIOClient {
    private static final Logger logger = Logger.getLogger(NIOClient.class.getName());
    private static final ExecutorService executor = Executors.newFixedThreadPool(10);

    public static void main(String[] args) {
        try {
            SocketChannel socketChannel = SocketChannel.open();
            socketChannel.configureBlocking(false);
            socketChannel.connect(new InetSocketAddress("localhost", 8080));

            while (!socketChannel.finishConnect()) {
                // 等待连接完成
            }

            executor.execute(() -> {
                try {
                    String message = "Hello, server!";
                    ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());
                    socketChannel.write(buffer);

                    buffer.clear();
                    int bytesRead = socketChannel.read(buffer);
                    if (bytesRead > 0) {
                        buffer.flip();
                        byte[] data = new byte[bytesRead];
                        buffer.get(data);
                        logger.info("Received from server: " + new String(data));
                        // 可以在这里处理接收到的数据
                    }
                } catch (IOException e) {
                    logger.severe("Error in NIO client: " + e.getMessage());
                } finally {
                    try {
                        socketChannel.close();
                    } catch (IOException e) {
                        logger.severe("Error in closing socket channel: " + e.getMessage());
                    }
                }
            });
        } catch (IOException e) {
            logger.severe("Error in NIO client: " + e.getMessage());
        }
    }
}

  6. 适用场景：
    NIO适用于高并发的网络应用，例如Web服务器、聊天服务器等，能够更高效地处理大量连接。

总的来说，NIO通过Selector、Channel和Buffer的组合，实现了非阻塞I/O，提高了系统的并发处理能力。然而，NIO编程相对复杂，需要处理事件的就绪状态，因此在实际应用中通常会使用NIO框架或者基于NIO的高级框架，如Netty。

AIO

在Java中，AIO（Asynchronous I/O）是一种基于事件和回调机制的I/O模型，相比于传统的BIO（Blocking I/O）和NIO（Non-blocking I/O），AIO更加适用于处理大量并发连接。下面我将详细介绍AIO的实现原理。

  1. 异步I/O：
    AIO的核心是异步I/O，它允许一个线程在等待数据就绪的同时继续做其他事情，当数据就绪后通过回调机制来处理数据。这种模型相比于NIO更加灵活，因为不需要手动检查就绪状态，而是通过事件通知来处理。

  2. 核心组件：

    • 异步通道（AsynchronousChannel）：用于进行异步I/O操作，包括文件和套接字等。
    • 异步操作结果（AsynchronousResult）：用于存储异步操作的结果，可以通过回调方式获取结果。
    • 异步处理器（AsynchronousHandler）：用于处理异步操作完成后的回调。

  3. 实现原理：

    • 服务端：服务端通过AsynchronousServerSocketChannel监听连接请求，一旦有连接到来，会调用accept方法，并通过回调方式处理连接就绪事件。
    • 客户端：客户端通过AsynchronousSocketChannel向服务端发起连接请求，连接建立后也可以通过回调方式处理后续的读写操作。

  4. 简单的AIO服务器示例代码：
    实现思路：针对企业级生产环境中高可用的通信需求，以下是一个更完善的AIO服务端和客户端的Java代码。该代码考虑了各种可能遇到的问题，并给出了切实可行的异常解决方案。同时，引入了日志打印服务，使用了Java自带的Logger类来记录日志，并使用了线程池来处理客户端的连接请求和数据读写操作，以提高并发处理能力。

    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.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.logging.Logger;

public class AIOServer {
    private static final Logger logger = Logger.getLogger(AIOServer.class.getName());
    private static final ExecutorService executor = Executors.newFixedThreadPool(10);

    public static void main(String[] args) {
        try {
            AsynchronousServerSocketChannel serverSocketChannel = AsynchronousServerSocketChannel.open();
            serverSocketChannel.bind(new InetSocketAddress(8080));

            serverSocketChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
                @Override
                public void completed(AsynchronousSocketChannel clientChannel, Void attachment) {
                    serverSocketChannel.accept(null, this); // 接受下一个连接
                    executor.execute(() -> handleRead(clientChannel));
                }

                @Override
                public void failed(Throwable exc, Void attachment) {
                    logger.severe("Error in accepting connection: " + exc.getMessage());
                }
            });

            // 阻止主线程退出
            Thread.currentThread().join();
        } catch (IOException | InterruptedException e) {
            logger.severe("Error in AIO server: " + e.getMessage());
        }
    }

    private static void handleRead(AsynchronousSocketChannel clientChannel) {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        clientChannel.read(buffer, null, new CompletionHandler<Integer, Void>() {
            @Override
            public void completed(Integer bytesRead, Void attachment) {
                if (bytesRead == -1) {
                    try {
                        clientChannel.close();
                    } catch (IOException e) {
                        logger.severe("Error in closing client channel: " + e.getMessage());
                    }
                    return;
                }

                buffer.flip();
                byte[] data = new byte[bytesRead];
                buffer.get(data);
                logger.info("Received from client: " + new String(data));
                // 可以在这里处理接收到的数据

                buffer.clear();
                clientChannel.read(buffer, null, this); // 继续读取数据
            }

            @Override
            public void failed(Throwable exc, Void attachment) {
                logger.severe("Error in reading from client: " + exc.getMessage());
            }
        });
    }
}

  5. 简单的AIO客户端示例代码：

    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.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Logger;

public class AIOClient {
    private static final Logger logger = Logger.getLogger(AIOClient.class.getName());
    private static final ExecutorService executor = Executors.newFixedThreadPool(10);

    public static void main(String[] args) {
        try {
            AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open();
            socketChannel.connect(new InetSocketAddress("localhost", 8080), null, new CompletionHandler<Void, Void>() {
                @Override
                public void completed(Void result, Void attachment) {
                    String message = "Hello, server!";
                    ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());
                    socketChannel.write(buffer, null, new CompletionHandler<Integer, Void>() {
                        @Override
                        public void completed(Integer bytesWritten, Void attachment) {
                            if (buffer.hasRemaining()) {
                                socketChannel.write(buffer, null, this); // 继续写入数据
                            } else {
                                buffer.clear();
                                socketChannel.read(buffer, null, new CompletionHandler<Integer, Void>() {
                                    @Override
                                    public void completed(Integer bytesRead, Void attachment) {
                                        buffer.flip();
                                        byte[] data = new byte[bytesRead];
                                        buffer.get(data);
                                        logger.info("Received from server: " + new String(data));
                                        // 可以在这里处理接收到的数据
                                    }

                                    @Override
                                    public void failed(Throwable exc, Void attachment) {
                                        logger.severe("Error in reading from server: " + exc.getMessage());
                                    }
                                });
                            }
                        }

                        @Override
                        public void failed(Throwable exc, Void attachment) {
                            logger.severe("Error in writing to server: " + exc.getMessage());
                        }
                    });
                }

                @Override
                public void failed(Throwable exc, Void attachment) {
                    logger.severe("Error in connecting to server: " + exc.getMessage());
                }
            });

            // 阻止主线程退出
            Thread.currentThread().join();
        } catch (IOException | InterruptedException e) {
            logger.severe("Error in AIO client: " + e.getMessage());
        }
    }
}

  6. 适用场景：
    AIO适用于需要处理大量并发连接且对性能要求较高的场景，例如高性能的网络服务器、金融交易系统等。

总的来说，AIO通过异步I/O和事件回调机制，实现了高效的并发处理能力，相比于NIO更加灵活和高效。然而，AIO在Java中的实现相对较新，需要较高的技术要求，因此在实际应用中通常会使用成熟的AIO框架或者基于AIO的高级框架。

在Java中，有一些成熟的AIO框架或者基于AIO的高级框架，它们提供了更加便捷和高效的异步I/O编程方式。以下是一些常用的框架：

  1. Netty：
    Netty是一个基于NIO的高性能网络通信框架，但它也提供了对AIO的支持。Netty的异步事件驱动模型和高度可定制的架构使得它成为构建高性能、可扩展的网络应用程序的理想选择。Netty提供了丰富的功能，包括TCP/UDP传输、HTTP编解码、WebSocket支持等，广泛应用于网络服务器、分布式系统等领域。

  2. Grizzly：
    Grizzly是一个基于NIO的高性能网络框架，它提供了对AIO的支持，并且具有高度可扩展性和灵活性。Grizzly可以用于构建高性能的Web服务器、应用服务器等网络应用。

  3. Apache MINA：
    Apache MINA是一个基于NIO的网络应用框架，它提供了对AIO的支持，并且具有良好的扩展性和灵活性。MINA可以用于构建各种类型的网络应用，包括游戏服务器、即时通讯服务器等。

这些框架都提供了对AIO的封装和抽象，简化了异步I/O编程的复杂性，同时提供了丰富的功能和高性能的网络通信能力。在实际应用中，选择合适的框架取决于具体的需求和项目背景，但无论选择哪个框架，都可以极大地简化异步I/O编程的复杂性，提高开发效率和系统性能。

goTsHgo
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
详解Java 网络IO编程总结（BIO、NIO、AIO均含完整实例代码）
08-28
在本篇文章中，我们将通过完整的实例代码，展示 BIO、NIO 和 AIO 三种模型的使用方法，并对每种模型的优缺点进行分析。 本篇文章主要介绍了 Java 网络IO编程的三个模型，并提供了完整的实例代码，可以帮助读者快速...
Java新一代网络编程模型AIO原理
kaven
02-05 1488
Java新一代网络编程模型AIO原理及Linux系统AIO介绍 前言 从JDK 1.7版本开始，Java新加入的文件和网络IO特性称为NIO2(New IO2, 因为JDK1.4中已经有过一个NIO了)，包含了众多性能和功能上的改进，其中最重要的部分，就是对异步IO的支持，称为Java AIO(Asynchronous IO)。 因为AIO的实现需要充分调用OS，IO需要操作系统支持、并发也同样需...
BIO、NIO、AIO等IO模式详解(图文、代码示例解说)
dfBeautifulLive的博客
04-26 1112
1.BIO(blocking I/O) BIO是一个传统的IO，是一个阻塞的IO，当然都是这么说，那么堵塞在哪里呢，我们通过代码示例给大家解说 我先用程序模拟一个客户端连接服务端程序，建立一个socket连接来监听客户端,然后监听到了以后用getInputStream进行获取流然后死循环监听客户端的请求数据。 /** * 用BIO方式让客户端连接程序，监听服务端 * * @Autho...
JAVA AIO
m0_62943934的博客
04-19 665
AIO 用来解决数据复制阶段的阻塞问题 * 同步意味着，在进行读写操作时，线程需要等待结果，还是相当于闲置 * 异步意味着，在进行读写操作时，线程不必等待结果，而是将来由操作系统来通过回调方式由另外的线程来获得结果 > 异步模型需要底层操作系统（Kernel）提供支持 > > * Windows 系统通过 IOCP 实现了真正的异步 IO > * Linux 系统异步 IO 在 2.6 版本引入，但其底层实现还是用多路复用模拟了异步 IO，性能没有优势
JavaBIO基本使用以及阻塞问题分析
自律使我自由
10-19 778
简单认识BIO BIO在网络编程中指的是同步阻塞的网络模型（Blocking IO），Java中BIO一般就是我们使用java.io包下提供的一些用来实现网络编程的方法。 单线程代码演示 服务端 import java.io.BufferedReader; import java.io.InputStream; import java.io.InputStreamReader; import java.net.ServerSocket; import java.net.Socket; public cl
深入分析 Java IO （四）AIO
码灵的博客
06-15 538
前面我们对Java IOBIONIO进行了分析，本篇文章我们就来讲讲AIO的相关知识。从Java 1.7开始，Java 提供了AIO（异步I/O）。Java AIO 也被称为NIO2.0，提供了异步I/O的方式，用法和标准的I/O有非常大的差异。Java AIO 采用订阅-通知即应用程序向操作系统注册IO监听，然后继续做自己的事情。当操作系统发生IO事件，并且准备好数据后，在主动通知应用程序，触发相应的函数。Java BIO。
java aio_【Java】Java AIO使用
weixin_32973973的博客
02-12 335
欢迎关注公众号: 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基础--AIO
weixin_50204197的博客
02-01 396
java基础，AIO，同步，异步，阻塞，非阻塞
Java I/O（四）示例代码
yunyun1886358的专栏
11-10 506
使用Java 中的BIO，NIO，AIO，实现一个简单的客户端/服务端聊天系统
Java中网络IO的实现方式（BIO、NIO、AIO）介绍
08-31
根据不同的实现方式，可以分为三种：BIO（Blocking I/O）、NIO（Non-Blocking I/O）和AIO（Asynchronous I/O）。 BIO（Blocking I/O） BIO方式是Java中最早的网络IO实现方式。它的工作原理是：每个TCP连接到达...
Java BIO、NIO、AIO、Netty知识详解（值得珍藏）
01-11
Java中I/O是以流为基础进行数据的输入输出的，所有数据被串行化(所谓串行化就是数据要按顺序进行输入 输出)写入输出流。简单来说就是java通过io流方式和外部设备进行交互。 在Java类库中，IO部分的内容是很庞大的，...
高性能的java AIO通信框架 物联网参考
01-09
不到800行代码实现极简、易用、高性能的java AIO通信框架，也许是物联网开发的最佳选择
Java编程中的IO模型详解：BIO，NIO，AIO的区别与实际应用场景分析
01-04
IO模型决定了数据的传输方式，Java支持BIO，NIO，AIO三种IO模型。BIO是同步阻塞模型，特点是一对一的客户端与处理线程关系，适用场景是连接数量较小并且固定的，优点是编程简单，但对服务器资源要求高。NIO是同步非...
java中IO模型-AIO模型
m0_46853673的博客
10-02 3020
AIO模型介绍 AIO（Asynchronous I/O） 异步非阻塞模型， 在javajdk.17版本开始支持AIO，AIO模型需要操作系统的支持。 AIO最大的特性是异步能力，对socket和I/O起作用。 异步IO模型类似的 与NIO模型不同，读写操作为例，只需直接调用read和write的API即可，这方法都是异步的。 对于读操作:当有流可读是，系统会将可读的流传入到read方法的缓冲区，并通知应用程序。 读写都是异步的，完成之后会主动调用回调函数。 在JDK 1.7中，nio.2,主要在java
java之AIO实例
程序员的博客
03-31 1555
AIO介绍 JDK1.7升级了NIO类库，升级后的NIO类库被称为NIO 2.0，Java正式提供了异步文件I/O操作，同时提供了与UNIX网络编程事件驱动I/O对应的AIO。AIO是真正的异步非阻塞I/O。它不需要通过多路复用器（Selector）对注册的通道进行轮询操作即可实现异步读写，从而简化了NIO的编程模型。NIO 2.0引入了新的异步通道的概念，并提供了异步文件通道和异步套接字通道的...
Java中三种I/O模型 BIO,NIO,AIO
weixin_47414034的博客
12-07 512
UNIX 系统下， IO 模型一共有 5 种： 同步阻塞 I/O、同步非阻塞 I/O、I/O 多路复用、信号驱动 I/O 和异步 I/O。这也是我们经常提到的 5 种 IO 模型（1）同步阻塞I/O模型 应用程序发起read调用后，一直处于阻塞状态内核开始准备数据，直到把数据拷贝到应用程序，应用程序才被唤醒（2）同步非阻塞 IO 模型 应用程序会一直发起 read 调用，避免了一直阻塞直到数据就绪了，应用程序再次发起调用的时候，应用程序才进入阻塞状态，当数据拷贝完成，应用程序才被唤醒相比于同步阻塞 IO
Java I/O大揭秘：BIO、NIO、AIO到底有何区别？
孤芳不自赏
06-22 545
这篇文章你值得一阅！讲技术我觉得应该让外行也能看明白，而不是一堆专业术语堆砌，像在读天书一般，到最后感觉云里雾里。
浅谈(Java)AIO-异步IO
程序员乌拉的博客！
04-30 1505
阻塞式同步IO、非阻塞式同步IO、多路复用IO 这三种IO模型，以及JAVA对于这三种IO模型的支持。重点说明了IO模型是由操作系统提供支持，且这三种IO模型都是同步IO，都是采用的“应用程序不询问我，我绝不会主动通知”的方式。 异步IO则是采用“订阅-通知”模式: 即应用程序向操作系统注册IO监听，然后继续做自己的事情。当操作系统发生IO事件，并且准备好数据后，在主动通知应用程序，触发相应的函数:
Java AIO
JustinMars的博客
08-04 481
Java AIO
2024年Java常见的-BIO,NIO,AIO,Netty面试题
最新发布
04-20
主要是介绍java方面网络方面 网络通信方面的面试题，核心内容主要是关于BIO,NIO,AIO,Netty的面试，算是一套八股文吧，还是老话，该背的还是要背一背！！！

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值