详解Java中的五种IO模型

在Java中，输入输出（I/O）操作是非常核心的功能之一。Java提供了多种I/O模型，主要包括：字节流和字符流、阻塞I/O（BIO）、非阻塞I/O（NIO）、异步I/O（AIO）、以及直接内存访问（Direct Buffer）。下面将对这五种I/O模型进行详细阐述。

1. 字节流与字符流

Java中的I/O流分为字节流（InputStream和OutputStream）和字符流（Reader和Writer）。字节流处理的是原始的二进制数据，适合所有类型的I/O操作；而字符流则是专门用于处理文本数据，提供了对Unicode字符的支持。

// 字节流示例
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

public class ByteStreamExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt");
             FileOutputStream fos = new FileOutputStream("output.txt")) {

            int byteData;
            while ((byteData = fis.read()) != -1) {
                fos.write(byteData);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2. 阻塞I/O（BIO）

阻塞I/O是Java最传统的I/O处理方式。在这种模型中，当进行I/O操作时，线程会被阻塞直到操作完成。如果涉及到网络通信，一个线程会在尝试读取数据时被堵塞，直到数据可用或者连接关闭。

// BIO示例
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class BioServer {
    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(1234);
        while (true) {
            Socket clientSocket = serverSocket.accept();
            new Thread(new ClientHandler(clientSocket)).start();
        }
    }
}

class ClientHandler implements Runnable {
    private 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) {
                out.println("Echo: " + inputLine);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3. 非阻塞I/O（NIO）

非阻塞I/O使用了Java NIO包，它允许一个线程处理多个I/O操作。NIO引入了选择器（Selector），使得线程在等待I/O事件时不会被阻塞，从而提高了应用的并发性能。

// NIO示例
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.nio.channels SelectionKey;

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

        while (true) {
            selector.select();
            for (SelectionKey key : selector.selectedKeys()) {
                if (key.isAcceptable()) {
                    SocketChannel client = serverSocket.accept();
                    client.configureBlocking(false);
                    client.register(selector, SelectionKey.OP_READ);
                } else if (key.isReadable()) {
                    SocketChannel client = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(256);
                    int bytesRead = client.read(buffer);
                    if (bytesRead == -1) {
                        client.close();
                    } else {
                        buffer.flip();
                        client.write(buffer);
                    }
                }
                selector.selectedKeys().remove(key);
            }
        }
    }
}

4. 异步I/O（AIO）

Java AIO（Java 7引入）允许应用程序在执行I/O操作时可以继续处理其他任务。当I/O操作完成后，系统会通知相应的回调，避免了阻塞。

// AIO示例
import java.io.IOException;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.ByteBuffer;

public class AioServer {
    public static void main(String[] args) throws IOException {
        AsynchronousServerSocketChannel serverSocket = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(1234));
        serverSocket.accept(null, new AcceptHandler(serverSocket));
    }
}

class AcceptHandler implements java.nio.channels.CompletionHandler<AsynchronousSocketChannel, Void> {
    private final AsynchronousServerSocketChannel server;

    public AcceptHandler(AsynchronousServerSocketChannel server) {
        this.server = server;
    }

    @Override
    public void completed(AsynchronousSocketChannel result, Void attachment) {
        server.accept(null, this);
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        result.read(buffer, buffer, new ReadHandler(result));
    }

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

// ReadHandler类省略，类似于AcceptHandler，负责读取数据

5. 直接内存访问（Direct Buffer）

在Java中，直接内存缓冲区可以提高I/O操作的性能。它允许Java直接在堆外内存中分配缓冲区，从而减少了数据拷贝的次数。

// 直接内存缓存示例
import java.nio.ByteBuffer;

public class DirectBufferExample {
    public static void main(String[] args) {
        ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
        // 使用缓冲区
        buffer.put("Hello, Direct Buffer!".getBytes());
        buffer.flip();
        // 读取缓冲区
        while (buffer.hasRemaining()) {
            System.out.print((char) buffer.get());
        }
    }
}

总结

Java提供了丰富的I/O模型，以适应不同的应用需求。通过字节流和字符流，我们可以读取和写入数据；使用BIO，我们可以处理简单的阻塞I/O操作；而NIO和AIO则为高并发提供了更好的解决方案；直接内存访问则通过降低内存拷贝的开销来提升性能。熟练掌握这些I/O模型，能够帮助开发者在构建高效的Java应用时游刃有余。