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("內(nèi)存映射寫入失敗", e);
        throw new RuntimeException("文件寫入異常", e);
    }
}

public void writeWithDirectBuffer(String content, String filePath) {
    ByteBuffer directBuf = null;
    try {
        // 分配堆外內(nèi)存
        directBuf = ByteBuffer.allocateDirect(content.length());
        // 寫入數(shù)據(jù)到堆外內(nèi)存
        directBuf.put(content.getBytes(StandardCharsets.UTF_8));
        directBuf.flip();

        // 寫入文件
        try (FileChannel channel = new FileOutputStream(filePath).getChannel()) {
            channel.write(directBuf);
        }
    } catch (IOException e) {
        logger.error("直接緩沖區(qū)寫入失敗", 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+可以這樣實現(xiàn)O_DIRECT模式
FileChannel channel = (FileChannel) FileChannel.open(
    Paths.get(filePath),
    StandardOpenOption.CREATE,
    StandardOpenOption.WRITE,
    StandardOpenOption.DSYNC  // 相當(dāng)于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);
        // 強制刷盤，確保數(shù)據(jù)寫入物理存儲
        fos.flush(); // 將數(shù)據(jù)從JVM緩沖區(qū)刷到操作系統(tǒng)頁面緩存
        channel.force(true); // 同步數(shù)據(jù)和元數(shù)據(jù)，確保文件屬性（如修改時間）同步持久化
    } 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();
        }
        // 在處理完批量數(shù)據(jù)后刷新緩沖區(qū)
        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);
    }
}

# 監(jiān)控容器內(nèi)文件IO性能
docker stats --no-stream --format "{{.Container}}: {{.BlockIO}}"

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