// 1. allocate方式创建（堆缓冲区）
ByteBuffer buffer1 = ByteBuffer.allocate(1024);

// 2. allocateDirect方式创建（直接缓冲区）
ByteBuffer buffer2 = ByteBuffer.allocateDirect(1024);

// 3. wrap方式创建（包装现有数组）
byte[] bytes = new byte[1024];
ByteBuffer buffer3 = ByteBuffer.wrap(bytes);

Channel详解

Channel表示到实体（如文件、硬件设备、套接字等）的开放连接，可以进行读写操作。

Channel的主要类型

FileChannel：用于文件读写
SocketChannel：用于TCP网络连接
ServerSocketChannel：用于监听TCP连接请求
DatagramChannel：用于UDP网络通信

FileChannel的使用

// 创建FileChannel进行文件读取
FileInputStream fis = new FileInputStream("example.txt");
FileChannel readChannel = fis.getChannel();

// 创建FileChannel进行文件写入
FileOutputStream fos = new FileOutputStream("output.txt");
FileChannel writeChannel = fos.getChannel();

// 使用transferTo方法高效复制文件
readChannel.transferTo(0, readChannel.size(), writeChannel);

SocketChannel的使用

// 创建客户端SocketChannel
SocketChannel client = SocketChannel.open();
client.connect(new InetSocketAddress("localhost", 8080));

// 创建服务端SocketChannel
ServerSocketChannel server = ServerSocketChannel.open();
server.bind(new InetSocketAddress(8080));
SocketChannel clientChannel = server.accept();

Selector详解

Selector是NIO中用于实现I/O多路复用的关键组件，它允许单线程管理多个Channel。

Selector的工作原理

将多个Channel注册到Selector上
调用select()方法等待I/O事件
获取就绪的Channel并处理相应的事件

Selector的使用步骤

// 1. 创建Selector
Selector selector = Selector.open();

// 2. 创建Channel并设置为非阻塞模式
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.configureBlocking(false);

// 3. 将Channel注册到Selector
serverChannel.register(selector, SelectionKey.OP_ACCEPT);

// 4. 轮询I/O事件
while (true) {
    int readyChannels = selector.select();
    if (readyChannels == 0) continue;
    
    Set<SelectionKey> selectedKeys = selector.selectedKeys();
    Iterator<SelectionKey> keyIterator = selectedKeys.iterator();
    
    while (keyIterator.hasNext()) {
        SelectionKey key = keyIterator.next();
        
        if (key.isAcceptable()) {
            // 处理连接请求
        } else if (key.isReadable()) {
            // 处理读事件
        }
        
        keyIterator.remove();
    }
}

SelectionKey的事件类型

OP_ACCEPT：接受连接请求
OP_CONNECT：完成连接操作
OP_READ：有数据可读
OP_WRITE：可以写入数据

内存映射文件

内存映射文件是NIO提供的高性能文件访问机制，它将文件的一部分直接映射到内存中。

内存映射的优势

高性能：避免了数据在用户空间和内核空间之间的复制
大文件支持：可以处理超过JVM内存限制的大文件
随机访问：支持文件的随机访问

内存映射的使用

// 创建内存映射缓冲区
RandomAccessFile file = new RandomAccessFile("largefile.dat", "r");
FileChannel channel = file.getChannel();
MappedByteBuffer mappedBuffer = channel.map(
    FileChannel.MapMode.READ_ONLY, 0, channel.size());

// 直接访问映射的数据
for (int i = 0; i < mappedBuffer.capacity(); i++) {
    byte b = mappedBuffer.get(i);
    // 处理数据
}

Scatter/Gather操作

Scatter/Gather是NIO提供的高级I/O操作，可以将数据分散到多个缓冲区或从多个缓冲区聚集数据。

Scatter操作

Scatter操作将从Channel读取的数据分散到多个缓冲区中：

ByteBuffer header = ByteBuffer.allocate(128);
ByteBuffer body = ByteBuffer.allocate(1024);
ByteBuffer[] buffers = {header, body};

// 从Channel读取数据到多个缓冲区
channel.read(buffers);

Gather操作

Gather操作将多个缓冲区中的数据聚集写入到Channel：

ByteBuffer header = ByteBuffer.wrap("HEADER".getBytes());
ByteBuffer body = ByteBuffer.wrap("BODY CONTENT".getBytes());
ByteBuffer[] buffers = {header, body};

// 将多个缓冲区的数据写入Channel
channel.write(buffers);

文件锁

NIO提供了文件锁机制，用于协调多个进程对同一文件的访问。

文件锁的类型

排它锁（Exclusive Lock）：阻止其他进程访问文件
共享锁（Shared Lock）：允许多个进程同时读取文件

文件锁的使用

// 获取文件锁
RandomAccessFile file = new RandomAccessFile("lockedfile.txt", "rw");
FileChannel channel = file.getChannel();
FileLock lock = channel.lock(); // 获取排它锁

try {
    // 执行文件操作
    // ...
} finally {
    // 释放锁
    lock.release();
    channel.close();
    file.close();
}

NIO.2特性

Java 7引入了NIO.2（也称为AIO），提供了更丰富的文件系统操作API。

Path和Paths

NIO.2引入了Path接口来表示文件路径：

// 创建Path对象
Path path = Paths.get("/home/user/file.txt");
Path path2 = Paths.get("C:\\Users\\user\\file.txt");

// Path操作
Path parent = path.getParent();
Path fileName = path.getFileName();
Path resolved = path.resolve("subdir/file.txt");

Files工具类

Files类提供了丰富的文件操作方法：

// 文件复制
Files.copy(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);

// 文件删除
Files.deleteIfExists(path);

// 文件属性读取
long size = Files.size(path);
boolean exists = Files.exists(path);
boolean isDirectory = Files.isDirectory(path);

// 文件遍历
Files.walkFileTree(startingDir, new SimpleFileVisitor<Path>() {
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
        System.out.println("文件: " + file);
        return FileVisitResult.CONTINUE;
    }
});

NIO性能优化

缓冲区大小优化

选择合适的缓冲区大小对性能有重要影响：

// 小缓冲区会导致频繁的系统调用
ByteBuffer smallBuffer = ByteBuffer.allocate(128); // 不推荐

// 大缓冲区可能导致内存浪费
ByteBuffer largeBuffer = ByteBuffer.allocate(1024 * 1024); // 可能过大

// 合适的缓冲区大小通常是4KB-64KB
ByteBuffer optimalBuffer = ByteBuffer.allocate(8192); // 推荐

直接缓冲区vs堆缓冲区

// 堆缓冲区 - 数据在JVM堆中
ByteBuffer heapBuffer = ByteBuffer.allocate(1024);

// 直接缓冲区 - 数据在本地内存中
ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024);

// 直接缓冲区适合：
// 1. 长时间存在的缓冲区
// 2. 频繁进行本地I/O操作的缓冲区
// 3. 大型缓冲区

内存映射文件优化

// 对于大文件，内存映射通常比传统I/O更快
MappedByteBuffer mappedBuffer = fileChannel.map(
    FileChannel.MapMode.READ_ONLY, 0, fileChannel.size());

// 注意：内存映射文件在32位JVM上可能受限于地址空间

NIO实际应用场景

1. 高性能文件处理

public class HighPerformanceFileCopy {
    public static void copyFile(Path source, Path target) throws IOException {
        try (FileChannel sourceChannel = FileChannel.open(source, StandardOpenOption.READ);
             FileChannel targetChannel = FileChannel.open(target, StandardOpenOption.CREATE, 
                                                          StandardOpenOption.WRITE, 
                                                          StandardOpenOption.TRUNCATE_EXISTING)) {
            
            // 使用transferTo进行高效文件复制
            sourceChannel.transferTo(0, sourceChannel.size(), targetChannel);
        }
    }
}

2. 网络服务器

public class NIOServer {
    public void startServer(int port) throws IOException {
        Selector selector = Selector.open();
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        serverChannel.configureBlocking(false);
        serverChannel.bind(new InetSocketAddress(port));
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);
        
        while (true) {
            selector.select();
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> iter = selectedKeys.iterator();
            
            while (iter.hasNext()) {
                SelectionKey key = iter.next();
                
                if (key.isAcceptable()) {
                    handleAccept(key, selector);
                } else if (key.isReadable()) {
                    handleRead(key);
                }
                
                iter.remove();
            }
        }
    }
}

3. 异步文件处理

public class AsyncFileProcessor {
    private final ExecutorService executor = Executors.newFixedThreadPool(10);
    
    public Future<String> processFileAsync(Path file) {
        return executor.submit(() -> {
            try {
                // 使用NIO处理文件
                String content = new String(Files.readAllBytes(file));
                // 处理文件内容
                return "处理完成: " + file.getFileName();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        });
    }
}

NIO最佳实践

1. 合理使用缓冲区

// 好的做法：重用缓冲区
public class BufferReuseExample {
    private final ByteBuffer buffer = ByteBuffer.allocate(8192);
    
    public void processData(Channel channel) throws IOException {
        buffer.clear(); // 清空缓冲区
        int bytesRead = channel.read(buffer);
        if (bytesRead > 0) {
            buffer.flip(); // 切换到读模式
            // 处理数据
            processBuffer(buffer);
        }
    }
}

// 避免：频繁创建缓冲区
public void badExample(Channel channel) throws IOException {
    ByteBuffer buffer = ByteBuffer.allocate(8192); // 每次都创建新缓冲区
    channel.read(buffer);
    // ...
}

2. 正确处理SelectionKey

// 好的做法：处理完后移除SelectionKey
while (keyIterator.hasNext()) {
    SelectionKey key = keyIterator.next();
    
    try {
        if (key.isAcceptable()) {
            handleAccept(key);
        } else if (key.isReadable()) {
            handleRead(key);
        }
    } finally {
        keyIterator.remove(); // 处理完后移除
    }
}

// 避免：忘记移除SelectionKey
while (keyIterator.hasNext()) {
    SelectionKey key = keyIterator.next();
    
    if (key.isAcceptable()) {
        handleAccept(key);
    } else if (key.isReadable()) {
        handleRead(key);
    }
    // 忘记调用keyIterator.remove()
}

3. 异常处理

// 好的做法：正确处理Channel异常
private void handleRead(SelectionKey key) {
    SocketChannel client = (SocketChannel) key.channel();
    
    try {
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        int bytesRead = client.read(buffer);
        
        if (bytesRead == -1) {
            // 客户端关闭连接
            client.close();
            key.cancel();
        } else if (bytesRead > 0) {
            // 处理数据
            processBuffer(buffer);
        }
    } catch (IOException e) {
        // 处理I/O异常
        try {
            client.close();
        } catch (IOException closeException) {
            // 记录关闭异常
        }
        key.cancel();
    }
}

NIO的局限性

1. 复杂性

NIO相比传统I/O更加复杂，需要理解Buffer、Channel、Selector等概念。

2. 平台依赖性

某些NIO特性在不同操作系统上的表现可能不同。

3. 内存管理

直接缓冲区的内存不在JVM堆中，需要特别注意内存管理。

4. 调试困难

NIO程序的调试比传统I/O程序更加困难。

包结构说明

为了更好地组织代码，我们将NIO相关的类放在com.ibz.nio包中：

src/main/java/com/ibz/nio/
├── NIOBasicsDemo.java        // NIO基础演示
├── NIOAdvancedDemo.java      // NIO高级演示
├── NIOApplicationDemo.java   // NIO实际应用演示
└── NIOPerformanceDemo.java   // NIO性能分析演示

运行示例

要运行NIO详解示例，使用以下命令：

# 运行NIO基础演示
mvn exec:java -Dexec.mainClass="com.ibz.nio.NIOBasicsDemo"

# 运行NIO高级演示
mvn exec:java -Dexec.mainClass="com.ibz.nio.NIOAdvancedDemo"

# 运行NIO实际应用演示
mvn exec:java -Dexec.mainClass="com.ibz.nio.NIOApplicationDemo"

# 运行NIO性能分析演示
mvn exec:java -Dexec.mainClass="com.ibz.nio.NIOPerformanceDemo"

总结

NIO是Java中一个强大的I/O处理机制，它提供了比传统I/O更高效的I/O操作方式。通过学习本教程，您应该能够：

理解NIO的基本概念：掌握Buffer、Channel、Selector等核心组件
掌握NIO API的使用：熟练使用各种类型的Buffer和Channel
实现非阻塞I/O：使用Selector实现单线程管理多个连接
处理大文件：使用内存映射文件高效处理大文件
优化I/O性能：了解NIO性能优化的方法和技巧
应用NIO技术：在实际项目中合理使用NIO机制

学习建议

循序渐进：从基础的Buffer和Channel开始，逐步学习高级特性
实践为主：通过实际编码练习掌握NIO API的使用
关注性能：了解NIO的性能特点，选择合适的缓冲区大小和类型
注意异常：NIO程序需要仔细处理各种异常情况
阅读源码：通过阅读开源框架源码理解NIO的实际应用

NIO是现代Java开发中不可或缺的技术，特别是在高性能服务器和大数据处理场景中。通过深入学习和实践，您将能够更好地利用这一强大特性来解决复杂的I/O处理问题。