Java NIO&AIO

最新推荐文章于 2024-05-24 02:08:26 发布

DevDiary

最新推荐文章于 2024-05-24 02:08:26 发布

阅读量939

点赞数 22

分类专栏： Java 文章标签： java nio 多路复用 AIO

本文链接：https://blog.csdn.net/www_tlj/article/details/138725562

版权

Java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

多路复用概念介绍

多路复用是一个在计算机网络、操作系统，以及软件开发中广泛使用的技术，它允许单一的资源（如网络连接或者CPU）同时服务于多个请求或多个应用程序。在I/O操作（输入/输出操作）的上下文中，多路复用通常指的是使用单一的线程或少量线程来同时处理多个I/O请求。

多路复用的主要形式

I/O多路复用（在网络编程中常见）：
- 使用单一的线程监听多个网络连接，处理所有的输入和输出请求。这通常涉及到监听哪些连接上有数据可以读取，或者哪些连接准备好可以写入数据而不会被阻塞。
- 常见的实现技术包括使用select, poll, 或 epoll（在Linux系统中）。
异步I/O（AIO）：
- 异步I/O模型允许应用程序启动一个或多个I/O操作，然后继续执行其他任务，无需等待这些操作完成。当I/O操作实际完成时，应用程序将接收到通知。
- 在Java中，这通过使用AsynchronousFileChannel或AsynchronousSocketChannel等类实现。

多路复用与阻塞/非阻塞I/O的关系

阻塞I/O：在这种模型下，应用程序发起一个I/O操作后，必须等待操作完成才能继续执行。在等待期间，应用程序的线程被挂起。
非阻塞I/O：在非阻塞模式下，I/O调用将立即返回一个状态，告诉应用程序数据是否可用。如果数据未就绪，应用程序可以做其他事情，而不是等待，从而提高了应用程序的效率。

Java NIO中的多路复用

Java的NIO库提供了基于通道（Channel）和缓冲区（Buffer）的I/O操作，以及一个选择器（Selector）机制，用于非阻塞的多路复用I/O操作。通过使用选择器，一个单独的线程可以监控多个输入源的数据状态，实现多路复用：

选择器（Selector）：一个可以监控一组通道的对象，用来检查哪一个或哪几个通道已经准备好进行读取或写入。
通道（Channel）：类似于传统的流，但它们可以被设置为非阻塞模式。在非阻塞模式下，应用程序可以请求读写操作，并且立即得到返回，不需要等待操作实际完成。

通过选择器，一个线程可以有效地管理多个通道的I/O操作，这样即使在处理大量连接时也不需要为每个连接创建一个线程，从而大幅度降低资源消耗和提高效率。这种模型非常适合需要处理大量并发连接的服务器，例如Web服务器或应用服务器。

Java NIO&AIO简介

Java NIO（New Input/Output）和 AIO（Asynchronous Input/Output）都是Java平台上处理非阻塞I/O的技术，但它们在处理I/O操作的方式和实现机制上有着显著的差异。以下是NIO和AIO之间的主要区别：

1. 操作模式

NIO 是基于事件驱动的非阻塞I/O模型。它使用**选择器（Selectors）和通道（Channels）**的概念，通过一个线程来监控多个输入通道，看是否有数据准备好可以被读取或写入。当数据准备好时，系统将通知应用程序，应用程序再进行实际的读写操作。
AIO 是真正的异步I/O，它不需要周期性地检查数据是否可用。AIO引入了异步通道的概念，允许应用程序直接进行读写操作，并在操作完成后通过回调函数或者Future对象处理结果。

2. 性能和资源利用

NIO 虽然是非阻塞的，但在处理大量连接时可能需要频繁地检查所有连接的状态，这种模型可能导致资源的浪费（尽管相比于传统的阻塞IO已经大幅改进）。
AIO 提供了更高的性能和更好的资源利用率，在处理成千上万的并发连接时表现更优，因为它通过操作系统的直接支持来异步处理I/O操作，减少了不必要的CPU消耗。

3. 应用场景

NIO 适合于连接数目较多但每个连接上的数据传输量不是特别大的场景，如网络服务器。
AIO 更适合于高负载、高并发的应用场景，特别是在I/O操作非常耗时的情况下（如大文件传输），能够有效地提升性能。

4. API复杂度

NIO 的API相对复杂，需要管理缓冲区、选择键（SelectionKey）等，同时还需要处理线程安全和数据同步等问题。
AIO 的API设计更为简洁直观，使用起来更加方便，特别是在进行复杂的异步操作时，可以使代码更加清晰。

5. 支持和可用性

NIO 从Java 1.4开始引入，而完整的NIO.2（包括对文件系统的改进）是在Java 7中引入的。
AIO 是在Java 7中引入的，是Java平台对真异步I/O的支持。

总之，选择NIO还是AIO主要取决于具体的应用需求和预期的系统负载。对于需要处理大量并发连接且每个连接上的数据量不是很大的应用，NIO可能是一个更好的选择。而对于那些I/O操作非常耗时且需要高效率处理的应用，AIO可能更合适。

NIO编程

在Java中使用NIO（非阻塞IO）通常涉及到使用通道（Channels）和缓冲区（Buffers）来进行I/O操作，以及选择器（Selectors）来管理多个通道。这里将通过一个简单的服务器示例，来展示如何在Java中实现基于NIO的编程实践。

NIO编程关键组件

通道 (Channel)：类似于流，但主要区别在于通道是双向的，可以读也可以写。最常用的是SocketChannel和ServerSocketChannel。
缓冲区 (Buffer)：数据的容器。数据从通道读入缓冲区，从缓冲区写入通道。例如ByteBuffer。
选择器 (Selector)：可以监视多个通道的IO状况，是单线程管理多个连接实现非阻塞IO的关键。

示例：基于NIO的Echo服务器

以下是一个简单的Echo服务器实现，该服务器会将客户端发送的消息原样返回。

步骤1：设置服务器通道和选择器

import java.net.*;
import java.nio.*;
import java.nio.channels.*;
import java.nio.charset.StandardCharsets;
import java.util.*;

public class EchoServer {
    public static void main(String[] args) throws Exception {
        // 创建选择器
        Selector selector = Selector.open();

        // 打开服务器Socket通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false); // 设置为非阻塞模式
        serverSocketChannel.socket().bind(new InetSocketAddress(8080));
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

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

        while (true) {
            // 非阻塞模式，选择器每隔一定时间检查一次注册的通道
            if (selector.select() == 0) {
                continue;
            }

            // 获取所有接收事件的SelectionKey实例
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> iter = selectedKeys.iterator();

            while (iter.hasNext()) {
                SelectionKey key = iter.next();

                // 根据事件类型进行处理
                if (key.isAcceptable()) {
                    // 接受客户端连接请求
                    handleAccept(serverSocketChannel, selector);
                } else if (key.isReadable()) {
                    // 读取数据
                    handleRead(key);
                }
                iter.remove();
            }
        }
    }

    private static void handleAccept(ServerSocketChannel serverSocketChannel, Selector selector) throws Exception {
        SocketChannel clientChannel = serverSocketChannel.accept();
        clientChannel.configureBlocking(false);
        clientChannel.register(selector, SelectionKey.OP_READ);
        System.out.println("Accepted connection from " + clientChannel);
    }

    private static void handleRead(SelectionKey key) throws Exception {
        SocketChannel clientChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int numRead = clientChannel.read(buffer);
        if (numRead == -1) {
            clientChannel.close();
            key.cancel();
            System.out.println("Connection closed by client");
            return;
        }

        // 回显数据
        buffer.flip();
        byte[] data = new byte[buffer.remaining()];
        buffer.get(data);
        System.out.println("Received: " + new String(data, StandardCharsets.UTF_8));

        // 将数据写回客户端
        clientChannel.write(ByteBuffer.wrap(data));
    }
}

解释

服务器设置：服务器通道被设置为非阻塞并注册到选择器。关注的事件是OP_ACCEPT，表示服务器准备好接受新的客户端连接。
事件循环：服务器在一个无限循环中运行，等待并处理事件（接受连接或读取数据）。
处理连接和读取：当selector发现有新的客户端连接时，它会接受连接并将返回的SocketChannel设置为非阻塞，然后注册到选择器上，关注读事件。读事件触发时，数据被读入ByteBuffer，并简单地回显到客户端。

这个示例展示了使用Java NIO来创建一个简单的服务器的基本步骤。NIO编程比标准的IO编程更复杂，但它能更有效地处理成千上万的并发连接，尤其是在高负载环境下。

AIO编程

在Java中，AIO（异步IO）是通过Java NIO 2的扩展实现的，它在Java 7中被引入作为一种真正的异步非阻塞IO模型。AIO提供了一种机制，允许应用程序在I/O操作完成时接收通知，而无需持续检查或等待I/O操作的完成。这通过使用异步通道和完成处理器（或Future对象）实现。

AIO编程的关键组件

异步通道：这些是用于数据读写的通道，如AsynchronousSocketChannel和AsynchronousServerSocketChannel。
完成处理器：一个实现了特定回调方法的对象，当异步操作完成时被调用。
Future对象：另一种处理异步操作结果的方式，可以用来查询操作是否完成，或阻塞等待操作完成。

示例：基于AIO的Echo服务器

这个示例将展示如何使用AIO来实现一个简单的Echo服务器，该服务器异步地接收客户端连接和数据，并将接收到的数据原样返回给客户端。

步骤1：创建服务器通道

import java.net.*;
import java.nio.*;
import java.nio.channels.*;
import java.util.concurrent.*;

public class AsyncEchoServer {
    public static void main(String[] args) {
        try {
            // 打开异步服务器通道
            AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open();
            serverChannel.bind(new InetSocketAddress(8080));
            System.out.println("Server is listening at " + 8080);

            serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
                @Override
                public void completed(AsynchronousSocketChannel clientChannel, Void attachment) {
                    // 一旦接受连接，再次准备接受新的连接
                    serverChannel.accept(null, this);
                    handleClient(clientChannel);
                }

                @Override
                public void failed(Throwable exc, Void attachment) {
                    System.out.println("Failed to accept new connection");
                    exc.printStackTrace();
                }
            });

            // 服务器需要一直运行，使用CountDownLatch来阻塞
            new CountDownLatch(1).await();
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }

    private static void handleClient(AsynchronousSocketChannel clientChannel) {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        clientChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
            @Override
            public void completed(Integer result, ByteBuffer attachment) {
                attachment.flip();
                clientChannel.write(attachment, attachment, new CompletionHandler<Integer, ByteBuffer>() {
                    @Override
                    public void completed(Integer result, ByteBuffer buffer) {
                        if (buffer.hasRemaining()) {
                            buffer.compact();
                            clientChannel.read(buffer, buffer, this);
                        } else {
                            try {
                                clientChannel.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    }

                    @Override
                    public void failed(Throwable exc, ByteBuffer attachment) {
                        System.out.println("Failed to write data to client");
                        exc.printStackTrace();
                        try {
                            clientChannel.close();
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    }
                });
            }

            @Override
            public void failed(Throwable exc, ByteBuffer attachment) {
                System.out.println("Failed to read data from client");
                exc.printStackTrace();
                try {
                    clientChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

解释

异步服务器通道：服务器使用AsynchronousServerSocketChannel来监听端口。这个通道被配置为异步模式，并绑定到指定端口。
接受连接：使用accept方法开始异步接受新连接，连接到来时会调用CompletionHandler的completed方法。
处理客户端数据：在处理客户端连接时，同样使用异步读写操作，通过传递CompletionHandler来处理读写完成后的事件。

这个示例展示了AIO编程的一些基本模式，如使用异步通道和完成处理器。这种模式可以有效地处理大量并发连接，而不会造成线程阻塞，从而提高了应用程序的性能和响应能力。

DevDiary

关注

22
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
Java NIO&AIO

Java NIO（New Input/Output）和 AIO（Asynchronous Input/Output）都是Java平台上处理非阻塞I/O的技术，但它们在处理I/O操作的方式和实现机制上有着显著的差异。
复制链接

扫一扫