IO 性能优化

// 不推荐：无缓冲
FileInputStream fis = new FileInputStream("file.txt");
int b;
while ((b = fis.read()) != -1) {  // 每次读 1 字节，大量系统调用
    // 处理
}
 
// 推荐：使用缓冲流
BufferedInputStream bis = new BufferedInputStream(
    new FileInputStream("file.txt"));
int b;
while ((b = bis.read()) != -1) {  // 批量读取，减少系统调用
    // 处理
}

// 默认缓冲区大小：8KB
BufferedInputStream bis = new BufferedInputStream(
    new FileInputStream("file.txt"), 64 * 1024);  // 64KB 缓冲
 
// 自定义缓冲读取
byte[] buffer = new byte[64 * 1024];
int len;
while ((len = fis.read(buffer)) != -1) {
    // 处理 buffer
}

// 堆内存 Buffer
ByteBuffer heapBuffer = ByteBuffer.allocate(1024);
 
// 直接内存 Buffer（零拷贝友好）
ByteBuffer directBuffer = ByteBuffer.allocateDirect(1024);

// 频繁 IO 操作使用直接内存
ByteBuffer buffer = ByteBuffer.allocateDirect(64 * 1024);
 
// 短生命周期使用堆内存
ByteBuffer buffer = ByteBuffer.allocate(1024);

// BIO：每个连接一个线程
while (true) {
    Socket socket = serverSocket.accept();
    new Thread(() -> handle(socket)).start();  // 线程资源有限
}
 
// NIO：一个线程管理多个连接
Selector selector = Selector.open();
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
 
while (true) {
    selector.select();
    // 处理就绪的 Channel
}

// 传统 IO：4 次拷贝，4 次上下文切换
byte[] data = Files.readAllBytes(Paths.get("file.txt"));
socket.getOutputStream().write(data);
 
// 零拷贝：2 次 DMA 拷贝，2 次上下文切换
FileChannel fileChannel = new FileInputStream("file.txt").getChannel();
fileChannel.transferTo(0, fileChannel.size(), socketChannel);

// 不推荐：逐行读取处理
List<String> lines = Files.readAllLines(path);  // 一次性加载到内存
for (String line : lines) {
    process(line);
}
 
// 推荐：流式处理
try (Stream<String> stream = Files.lines(path)) {
    stream.forEach(this::process);  // 逐行处理，内存友好
}

// 不推荐：多次写入
for (String line : lines) {
    writer.write(line);  // 多次系统调用
}
 
// 推荐：批量写入
StringBuilder sb = new StringBuilder();
for (String line : lines) {
    sb.append(line).append("\n");
}
writer.write(sb.toString());  // 一次写入

// 异步读取
AsynchronousFileChannel channel = AsynchronousFileChannel.open(
    Paths.get("file.txt"), StandardOpenOption.READ);
 
ByteBuffer buffer = ByteBuffer.allocate(1024);
Future<Integer> future = channel.read(buffer, 0);
 
// 做其他事情...
 
Integer bytesRead = future.get();  // 阻塞等待完成
 
// 回调方式
channel.read(buffer, 0, null, new CompletionHandler<Integer, Void>() {
    @Override
    public void completed(Integer result, Void attachment) {
        // 读取完成
    }
    
    @Override
    public void failed(Throwable exc, Void attachment) {
        // 处理异常
    }
});

AsynchronousServerSocketChannel serverChannel = 
    AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(8080));
 
serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
    @Override
    public void completed(AsynchronousSocketChannel client, Void attachment) {
        serverChannel.accept(null, this);  // 继续接受连接
        // 处理客户端
    }
    
    @Override
    public void failed(Throwable exc, Void attachment) {
        // 处理异常
    }
});

// 随机读写：性能差
RandomAccessFile raf = new RandomAccessFile("file.txt", "rw");
raf.seek(100);  // 定位
raf.write(data);
raf.seek(500);  // 再定位
raf.write(data2);
 
// 顺序读写：性能好
try (FileChannel channel = new FileOutputStream("file.txt").getChannel()) {
    for (byte[] data : dataList) {
        channel.write(ByteBuffer.wrap(data));  // 顺序写入
    }
}

// 大文件处理
FileChannel channel = new RandomAccessFile("large.txt", "r").getChannel();
MappedByteBuffer buffer = channel.map(
    FileChannel.MapMode.READ_ONLY, 
    0, 
    Math.min(channel.size(), Integer.MAX_VALUE));
 
// 直接从内存读取
while (buffer.hasRemaining()) {
    byte b = buffer.get();
    // 处理
}

ServerSocketChannel serverChannel = ServerSocketChannel.open();
ServerSocket socket = serverChannel.socket();
 
socket.setReuseAddress(true);        // 允许端口重用
socket.setReceiveBufferSize(64 * 1024);  // 接收缓冲区大小
 
SocketChannel clientChannel = serverChannel.accept();
Socket clientSocket = clientChannel.socket();
 
clientSocket.setTcpNoDelay(true);    // 禁用 Nagle 算法
clientSocket.setKeepAlive(true);     // 保持连接
clientSocket.setSendBufferSize(64 * 1024);  // 发送缓冲区大小

// 压缩传输
try (GZIPOutputStream gzip = new GZIPOutputStream(
        socket.getOutputStream())) {
    gzip.write(data);
}
 
// 解压接收
try (GZIPInputStream gzip = new GZIPInputStream(
        socket.getInputStream())) {
    byte[] buffer = new byte[1024];
    int len;
    while ((len = gzip.read(buffer)) != -1) {
        // 处理
    }
}

// 文件监控
FileChannel channel = FileChannel.open(path);
long position = channel.position();
long size = channel.size();
 
// 网络监控
Socket socket = channel.socket();
int sendBuffer = socket.getSendBufferSize();
int receiveBuffer = socket.getReceiveBufferSize();