深入解析Java实现文件写入磁盘的全链路过程

public void writeWithFileOutputStream(String content, String filePath) {
    try (FileOutputStream fos = new FileOutputStream(filePath)) {
        byte[] bytes = content.getBytes(StandardCharsets.UTF_8);
        fos.write(bytes);
    } catch (IOException e) {
        logger.error("写入文件失败", e);
        throw new RuntimeException("文件写入异常", e);
    }
}

public void writeWithBuffer(String content, String filePath) {
    try (FileOutputStream fos = new FileOutputStream(filePath);
         BufferedOutputStream bos = new BufferedOutputStream(fos, 8192)) {
        byte[] bytes = content.getBytes(StandardCharsets.UTF_8);
        bos.write(bytes);
        // BufferedWriter在close时会自动flush
    } catch (IOException e) {
        logger.error("写入文件失败", e);
        throw new RuntimeException("文件写入异常", e);
    }
}

public void writeWithBuffer(String content, String filePath) {
    try (FileOutputStream fos = new FileOutputStream(filePath);
         BufferedOutputStream bos = new BufferedOutputStream(fos, 8192)) {
        byte[] bytes = content.getBytes(StandardCharsets.UTF_8);
        bos.write(bytes);
        // BufferedWriter在close时会自动flush
    } catch (IOException e) {
        logger.error("写入文件失败", e);
        throw new RuntimeException("文件写入异常", e);
    }
}

public void writeWithFiles(String content, String filePath) {
    try {
        Path path = Paths.get(filePath);
        Files.write(path, content.getBytes(StandardCharsets.UTF_8));
    } catch (IOException e) {
        logger.error("Files API写入文件失败", e);
        throw new RuntimeException("文件写入异常", e);
    }
}

public void writeWithMappedByteBuffer(String content, String filePath) {
    try (RandomAccessFile file = new RandomAccessFile(filePath, "rw");
         FileChannel channel = file.getChannel()) {
        byte[] bytes = content.getBytes(StandardCharsets.UTF_8);

        // 确保文件足够大，处理文件增长场景
        long fileSize = channel.size();
        if (fileSize < bytes.length) {
            channel.truncate(bytes.length);
        }

        MappedByteBuffer mappedBuffer = channel.map(
            FileChannel.MapMode.READ_WRITE,
            0,
            bytes.length
        );
        mappedBuffer.put(bytes);
        mappedBuffer.force(); // 强制刷新到磁盘
    } catch (IOException e) {
        logger.error("内存映射写入失败", e);
        throw new RuntimeException("文件写入异常", e);
    }
}

public void writeWithDirectBuffer(String content, String filePath) {
    ByteBuffer directBuf = null;
    try {
        // 分配堆外内存
        directBuf = ByteBuffer.allocateDirect(content.length());
        // 写入数据到堆外内存
        directBuf.put(content.getBytes(StandardCharsets.UTF_8));
        directBuf.flip();

        // 写入文件
        try (FileChannel channel = new FileOutputStream(filePath).getChannel()) {
            channel.write(directBuf);
        }
    } catch (IOException e) {
        logger.error("直接缓冲区写入失败", e);
        throw new RuntimeException("文件写入异常", e);
    } finally {
        // Java 9+可以使用以下方式释放DirectBuffer
        // if (directBuf instanceof sun.nio.ch.DirectBuffer) {
        //     ((sun.nio.ch.DirectBuffer) directBuf).cleaner().clean();
        // }
    }
}

// 在Java 11+可以这样实现O_DIRECT模式
FileChannel channel = (FileChannel) FileChannel.open(
    Paths.get(filePath),
    StandardOpenOption.CREATE,
    StandardOpenOption.WRITE,
    StandardOpenOption.DSYNC  // 相当于Linux的O_DIRECT
);

public void writeWithForcedSync(String content, String filePath) {
    try (FileOutputStream fos = new FileOutputStream(filePath);
         FileChannel channel = fos.getChannel()) {
        byte[] bytes = content.getBytes(StandardCharsets.UTF_8);
        fos.write(bytes);
        // 强制刷盘，确保数据写入物理存储
        fos.flush(); // 将数据从JVM缓冲区刷到操作系统页面缓存
        channel.force(true); // 同步数据和元数据，确保文件属性（如修改时间）同步持久化
    } catch (IOException e) {
        logger.error("写入文件失败", e);
        throw new RuntimeException("文件写入异常", e);
    }
}

// 批量写入示例
public void batchWrite(List<String> lines, String filePath) {
    try (BufferedWriter writer = new BufferedWriter(
            new FileWriter(filePath), 8192)) {
        for (String line : lines) {
            writer.write(line);
            writer.newLine();
        }
        // 在处理完批量数据后刷新缓冲区
        writer.flush();
    } catch (IOException e) {
        logger.error("批量写入失败", e);
        throw new RuntimeException("文件写入异常", e);
    }
}

public class ProductionLogWriter {
    private final BufferedWriter writer;
    private final ScheduledExecutorService scheduler;
    private static final int FLUSH_INTERVAL_MS = 1000;

    public ProductionLogWriter(String logPath) throws IOException {
        writer = new BufferedWriter(new FileWriter(logPath, true), 16384);
        scheduler = Executors.newSingleThreadScheduledExecutor(r -> {
            Thread t = new Thread(r, "log-flusher");
            t.setDaemon(true);
            return t;
        });

        // 定期刷盘，兼顾性能与可靠性
        scheduler.scheduleAtFixedRate(
            () -> {
                try {
                    writer.flush();
                } catch (IOException e) {
                    // 记录刷盘异常
                }
            },
            FLUSH_INTERVAL_MS,
            FLUSH_INTERVAL_MS,
            TimeUnit.MILLISECONDS
        );
    }

    public void writeLog(String logLine) throws IOException {
        writer.write(logLine);
        writer.newLine();
    }

    public void close() throws IOException {
        scheduler.shutdown();
        writer.flush();
        writer.close();
    }
}

public void transferFileEnhanced(String sourceFile, String destFile) {
    try (FileChannel srcChannel = new FileInputStream(sourceFile).getChannel();
         FileChannel destChannel = new FileOutputStream(destFile).getChannel()) {
        // 分块传输处理大文件
        long position = 0;
        long remaining = srcChannel.size();
        long chunkSize = 10 * 1024 * 1024; // 10MB块

        while (remaining > 0) {
            long count = Math.min(remaining, chunkSize);
            long transferred = srcChannel.transferTo(position, count, destChannel);

            // 处理可能的部分传输
            if (transferred < count) {
                remaining -= transferred;
                position += transferred;
            } else {
                remaining -= count;
                position += count;
            }
        }
    } catch (IOException e) {
        logger.error("文件传输失败", e);
        throw new RuntimeException("文件传输异常", e);
    }
}

# 监控容器内文件IO性能
docker stats --no-stream --format "{{.Container}}: {{.BlockIO}}"

# 查看写入性能瓶颈
docker exec -it <container> bash -c "iostat -x 1 | grep sda"