BIO、NIO和AIO

斗码士

已于 2024-02-29 15:27:08 修改

阅读量977

点赞数 15

于 2024-02-29 15:26:40 首次发布

本文链接：https://blog.csdn.net/qq_14926283/article/details/136371533

版权

开发技术专栏收录该内容

17 篇文章 0 订阅

订阅专栏

本文介绍了Java网络编程中的BIO（阻塞IO）、NIO（非阻塞IO）和AIO（异步IO）三种主要IO模型，讨论了它们的适用场景、优点和缺点，以及在选择IO模型时需考虑的因素。

摘要由CSDN通过智能技术生成

BIO、NIO和AIO是Java网络编程中的三种主要IO模型。

BIO（Blocking IO）：同步并阻塞，服务实现模式为一个连接对应一个线程，即客户端发送一个连接，服务端要有一个线程来处理。如果连接多了，线程数量不够，就只能等待，即会发生阻塞。BIO适用于连接数目比较小且固定的架构，对服务器要求比较高，并发局限于应用中。
NIO（Non-Blocking IO）：同步非阻塞，服务实现模式是一个线程可以处理多个连接，即客户端发送的连接都会注册到多路复用器上，然后进行轮询连接，有I/O请求就处理。NIO适用于连接数目多且连接比较短的架构，如聊天服务器、弹幕系统等，编程比较复杂。NIO以I/O块（buffer）的形式处理数据，效率比BIO的I/O流更高。NIO是面向缓冲区或面向块编程的，支持双向操作，而BIO则是单向的，要么是输入流要么是输出流。
AIO（Asynchronous IO）：异步非阻塞，引入了异步通道，采用的是proactor模式，特点是有效的请求才启动线程，先有操作系统完成再通知服务端。AIO适用于连接数目多且连接长的架构，如相册服务器。AIO是基于事件和回调机制进行异步IO操作，不需要线程主动去查询IO事件，当有数据可读时会通知给线程。

总的来说，三种IO模型各有优缺点，适用于不同的场景和需求。在选择合适的IO模型时，需要考虑并发量、连接时长、服务器资源等因素。

应用场景：

BIO（Blocking IO，阻塞IO）：

应用场景：适用于连接数比较小且固定的架构，例如早期的Web服务器。这种方式对服务器资源要求较高，因为每个连接都需要一个单独的线程。在JDK 1.4之前的版本中，这是唯一的IO模型选择。
优点：程序直观、简单易理解。
缺点：并发局限于应用中，当连接数增多时，需要更多的线程来处理，这可能导致系统资源耗尽。

NIO（Non-Blocking IO，非阻塞IO）：

应用场景：适用于连接数比较多且连接比较短的架构，如聊天服务器、网络聊天应用等。这种模型对编程的要求比较高，从JDK 1.4开始支持。
优点：通过多路复用器（Selector）可以同时处理多个连接，提高了系统的并发处理能力。
缺点：虽然解决了BIO中并发量的问题，但仍然需要轮询检查，因此CPU资源可能会有所浪费。

AIO（Asynchronous IO，异步IO）：

应用场景：适用于连接数比较多且连接比较长的架构，如相册服务器、大文件传输等。这种模型充分利用了操作系统的参与，对编程的要求也很高，从JDK 7开始支持。
优点：实现了真正的异步非阻塞IO操作，当数据准备好时，操作系统会通知应用程序，从而提高了系统的响应速度和效率。
缺点：编程复杂，需要深入理解异步编程模型和操作系统的支持。

下面是一个简单的Java代码示例，展示了如何使用BIO（Blocking I/O）模型创建一个基本的服务器和客户端。这个例子中的服务器使用`ServerSocket`来监听客户端连接，并为每个连接创建一个新的线程。客户端使用`Socket`来连接到服务器，并发送和接收数据。

BIO例子

**服务器端（Server.java）**:

import java.io.*;  
import java.net.ServerSocket;  
import java.net.Socket;  
  
public class Server {  
  
    public static void main(String[] args) throws IOException {  
        int port = 8080;  
        ServerSocket serverSocket = new ServerSocket(port);  
  
        System.out.println("Server started on port: " + port);  
  
        while (true) {  
            Socket clientSocket = serverSocket.accept(); // 阻塞等待客户端连接  
            System.out.println("Accepted connection from " + clientSocket.getRemoteSocketAddress());  
  
            new Thread(new ClientHandler(clientSocket)).start(); // 为每个客户端连接创建新线程  
        }  
    }  
  
    static class ClientHandler implements Runnable {  
        private final Socket socket;  
  
        public ClientHandler(Socket socket) {  
            this.socket = socket;  
        }  
  
        @Override  
        public void run() {  
            try (  
                    BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));  
                    PrintWriter out = new PrintWriter(socket.getOutputStream(), true)  
            ) {  
                String inputLine;  
                while ((inputLine = in.readLine()) != null) {  
                    System.out.println("Received from client: " + inputLine);  
                    out.println("Server response: " + inputLine);  
                }  
            } catch (IOException e) {  
                e.printStackTrace();  
            } finally {  
                try {  
                    socket.close();  
                } catch (IOException e) {  
                    e.printStackTrace();  
                }  
            }  
        }  
    }  
}

**客户端（Client.java）**:

import java.io.*;  
import java.net.Socket;  
  
public class Client {  
  
    public static void main(String[] args) throws IOException {  
        String hostname = "localhost";  
        int port = 8080;  
  
        try (  
                Socket socket = new Socket(hostname, port);  
                PrintWriter out = new PrintWriter(socket.getOutputStream(), true);  
                BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()));  
                BufferedReader stdIn = new BufferedReader(new InputStreamReader(System.in))  
        ) {  
            System.out.println("Connected to server");  
  
            String userInput;  
            while ((userInput = stdIn.readLine()) != null) {  
                out.println(userInput); // 发送数据到服务器  
                System.out.println("Sent to server: " + userInput);  
  
                String response = in.readLine(); // 接收来自服务器的数据  
                System.out.println("Received from server: " + response);  
            }  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}

NIO例子

**服务器端（NioServer.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;  
import java.util.Set;  
  
public class NioServer {  
  
    public static void main(String[] args) throws IOException {  
        int port = 8080;  
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();  
        serverSocketChannel.configureBlocking(false); // 设置为非阻塞模式  
        serverSocketChannel.socket().bind(new InetSocketAddress(port));  
  
        Selector selector = Selector.open();  
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); // 注册OP_ACCEPT事件  
  
        while (true) {  
            int readyChannels = selector.select(); // 阻塞等待就绪的Channel  
            if (readyChannels == 0) continue;  
  
            Set<SelectionKey> selectedKeys = selector.selectedKeys();  
            Iterator<SelectionKey> keyIterator = selectedKeys.iterator();  
  
            while (keyIterator.hasNext()) {  
                SelectionKey key = keyIterator.next();  
  
                if (key.isAcceptable()) { // 有新的连接  
                    SocketChannel client = serverSocketChannel.accept();  
                    client.configureBlocking(false);  
                    client.register(selector, SelectionKey.OP_READ);  
                    System.out.println("Accepted connection from " + client);  
                } else if (key.isReadable()) { // 可读  
                    SocketChannel client = (SocketChannel) key.channel();  
                    ByteBuffer buffer = ByteBuffer.allocate(1024);  
                    int bytesRead = client.read(buffer);  
                    if (bytesRead == -1) {  
                        client.close();  
                    } else {  
                        buffer.flip();  
                        while (buffer.hasRemaining()) {  
                            System.out.print((char) buffer.get());  
                        }  
                        client.register(selector, SelectionKey.OP_WRITE);  
                    }  
                } else if (key.isWritable()) { // 可写  
                    SocketChannel client = (SocketChannel) key.channel();  
                    ByteBuffer buffer = ByteBuffer.allocate(1024);  
                    buffer.put("Hello from server!".getBytes());  
                    buffer.flip();  
                    client.write(buffer);  
                    client.close();  
                }  
  
                keyIterator.remove();  
            }  
        }  
    }  
}

**客户端（NioClient.java）**:

import java.io.IOException;  
import java.net.InetSocketAddress;  
import java.nio.ByteBuffer;  
import java.nio.channels.SocketChannel;  
  
public class NioClient {  
  
    public static void main(String[] args) {  
        String host = "localhost";  
        int port = 8080;  
  
        try (SocketChannel clientChannel = SocketChannel.open()) {  
            clientChannel.configureBlocking(false); // 设置为非阻塞模式  
  
            // 异步连接服务器  
            clientChannel.connect(new InetSocketAddress(host, port));  
  
            // 等待连接完成  
            while (!clientChannel.finishConnect()) {  
                // 连接尚未完成，可以继续做其他事情  
                System.out.println("Connecting to server...");  
            }  
  
            System.out.println("Connected to server");  
  
            // 准备发送的数据  
            ByteBuffer writeBuffer = ByteBuffer.allocate(1024);  
            writeBuffer.put("Hello from improved client!".getBytes());  
            writeBuffer.flip();  
  
            // 发送数据  
            while (writeBuffer.hasRemaining()) {  
                clientChannel.write(writeBuffer);  
            }  
  
            // 准备接收服务器响应的缓冲区  
            ByteBuffer readBuffer = ByteBuffer.allocate(1024);  
  
            // 等待并读取服务器的响应  
            while (true) {  
                int bytesRead = clientChannel.read(readBuffer);  
                if (bytesRead == -1) {  
                    // 连接已关闭或没有数据可读  
                    break;  
                }  
  
                // 反转缓冲区，准备读取数据  
                readBuffer.flip();  
  
                // 处理接收到的数据  
                while (readBuffer.hasRemaining()) {  
                    System.out.print((char) readBuffer.get());  
                }  
  
                // 清除缓冲区，为下一次读取准备  
                readBuffer.clear();  
            }  
  
            // 关闭连接  
            clientChannel.close();  
  
        } catch (IOException e) {  
            e.printStackTrace();  
        }  
    }  
}

AIO例子

import java.io.IOException;  
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 AIOExample {  
  
    public static void main(String[] args) {  
        String filePath = "path_to_your_file.txt";  
  
        try (AsynchronousFileChannel fileChannel = AsynchronousFileChannel.open(Paths.get(filePath), StandardOpenOption.READ)) {  
  
            ByteBuffer buffer = ByteBuffer.allocate(1024);  
  
            // 异步读取操作  
            fileChannel.read(buffer, 0, buffer, new CompletionHandler<Integer, ByteBuffer>() {  
  
                @Override  
                public void completed(Integer result, ByteBuffer attachment) {  
                    // 当读取完成时调用此方法  
                    if (result == -1) {  
                        // 文件末尾  
                        System.out.println("End of file reached");  
                        return;  
                    }  
  
                    attachment.flip();  
                    while (attachment.hasRemaining()) {  
                        System.out.print((char) attachment.get());  
                    }  
  
                    attachment.clear();  
  
                    // 继续异步读取  
                    fileChannel.read(buffer, 0, attachment, this);  
                }  
  
                @Override  
                public void failed(Throwable exc, ByteBuffer attachment) {  
                    // 当读取失败时调用此方法  
                    exc.printStackTrace();  
                }  
            });  
  
            // 防止主线程退出  
            Thread.sleep(Long.MAX_VALUE);  
  
        } catch (IOException | InterruptedException e) {  
            e.printStackTrace();  
        }  
    }  
}