# 將 ext3 升級為 ext4（需先卸載分區(qū)）
sudo tune2fs -O extents,uninit_bg,dir_index /dev/sdXN
sudo e2fsck -f /dev/sdXN

# 查看目錄是否啟用 dir_index
sudo dumpe2fs /dev/sdXN | grep dir_index

# /etc/fstab 示例
/dev/sda1 / ext4 defaults,data=ordered 0 1

# 推薦用于數(shù)據(jù)庫/日志服務(wù)器
/dev/sdb1 /data ext4 defaults,noatime,nodiratime 0 2

import java.nio.file.*;
import java.nio.ByteBuffer;
import java.io.IOException;
public class Ext4OptimizedWriter {
    public static void writeWithAllocation(Path filePath, long fileSize) throws IOException {
        // 使用 fallocate 類似功能預(yù)分配空間
        try (FileChannel channel = FileChannel.open(filePath, 
                StandardOpenOption.WRITE, 
                StandardOpenOption.CREATE)) {
            // 預(yù)分配空間，減少后續(xù)碎片
            channel.truncate(fileSize);
            // 寫入數(shù)據(jù)
            ByteBuffer buffer = ByteBuffer.allocate(8192);
            for (int i = 0; i < fileSize / buffer.capacity(); i++) {
                buffer.clear();
                // 填充數(shù)據(jù)...
                buffer.put(("Chunk " + i + "\n").getBytes());
                buffer.flip();
                channel.write(buffer);
            }
        }
    }
    public static void main(String[] args) {
        Path path = Paths.get("/mnt/ext4_data/largefile.dat");
        try {
            writeWithAllocation(path, 1024 * 1024 * 100); // 100MB
            System.out.println("? 文件寫入完成，已預(yù)分配空間");
        } catch (IOException e) {
            System.err.println("? 寫入失敗: " + e.getMessage());
        }
    }
}

import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.StandardOpenOption;
public class DirectMappedExample {
    public static void useMemoryMapping(Path file) throws Exception {
        try (FileChannel channel = FileChannel.open(file, 
                StandardOpenOption.READ, 
                StandardOpenOption.WRITE)) {
            // 內(nèi)存映射文件 —— OS 自動管理緩存
            MappedByteBuffer buffer = channel.map(
                FileChannel.MapMode.READ_WRITE, 0, 1024 * 1024);
            buffer.put("Hello from memory-mapped world!".getBytes());
            buffer.force(); // 強(qiáng)制刷盤
            System.out.println("?? 數(shù)據(jù)已通過內(nèi)存映射寫入");
        }
    }
}

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
public class BatchWriteOptimizer {
    // ? 低效：每次寫一行都 flush
    public static void badPractice(Path file) throws IOException {
        try (FileWriter fw = new FileWriter(file.toString())) {
            for (int i = 0; i < 10000; i++) {
                fw.write("Line " + i + "\n");
                fw.flush(); // 強(qiáng)制刷盤，破壞延遲分配
            }
        }
    }
    // ? 高效：批量寫入 + 大緩沖區(qū)
    public static void goodPractice(Path file) throws IOException {
        // 使用 128KB 緩沖區(qū)
        try (BufferedWriter bw = Files.newBufferedWriter(file, 
                java.nio.charset.StandardCharsets.UTF_8, 
                java.util.EnumSet.of(StandardOpenOption.CREATE, StandardOpenOption.WRITE))) {
            for (int i = 0; i < 10000; i++) {
                bw.write("Line " + i + "\n");
            }
            // 自動 flush on close，觸發(fā)一次延遲分配
        }
        System.out.println("?? 批量寫入完成，充分利用 ext4 延遲分配");
    }
}

import java.io.RandomAccessFile;
import java.nio.channels.FileChannel;
public class FilePrefetcher {
    public static void prefetchFile(Path filePath) throws Exception {
        try (RandomAccessFile raf = new RandomAccessFile(filePath.toFile(), "r");
             FileChannel channel = raf.getChannel()) {
            // 建議內(nèi)核預(yù)讀 4MB
            channel.position(0);
            long fileSize = channel.size();
            int readAheadSize = Math.min((int) fileSize, 4 * 1024 * 1024);
            ByteBuffer buffer = ByteBuffer.allocateDirect(readAheadSize);
            channel.read(buffer);
            buffer.flip();
            // 實際處理邏輯...
            System.out.println("?? 文件預(yù)熱完成，提升后續(xù)順序讀取性能");
        }
    }
}

# 每2秒刷新一次，關(guān)注 %util 和 await
iostat -x 2

# 跟蹤 sda 設(shè)備的 IO
sudo blktrace -d /dev/sda -o trace
sudo blkparse trace -o trace.txt

sudo apt install fio   # Ubuntu/Debian
sudo yum install fio   # CentOS/RHEL

# seq-write.fio
[global]
bs=128k
ioengine=libaio
direct=1
size=1g
numjobs=1
[seq-write]
rw=write
filename=/mnt/ext4_test/testfile

fio seq-write.fio

# 設(shè)置預(yù)留空間為 1%
sudo tune2fs -m 1 /dev/sdb1

# 啟用 project quota（項目配額）
sudo tune2fs -O project /dev/sdb1

# 啟用大目錄索引
sudo tune2fs -O large_file,dir_index /dev/sdb1

# 強(qiáng)制檢查（需卸載分區(qū)）
sudo umount /dev/sdb1
sudo e2fsck -f /dev/sdb1
sudo mount /dev/sdb1 /mnt/data

# 應(yīng)返回 "ftype=1"
sudo xfs_info /var/lib/docker | grep ftype
# 對于 ext4，需確保掛載時未禁用 dir_index
mount | grep ext4

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: ext4-optimized
provisioner: kubernetes.io/aws-ebs
parameters:
  type: gp3
mountOptions:
  - noatime
  - nodiratime
  - data=ordered

# 查找被刪除但仍占用空間的文件
lsof +L1

# 重啟相關(guān)進(jìn)程或 kill -HUP 釋放

# 格式化時指定更多 inode
sudo mkfs.ext4 -N 10000000 /dev/sdc1  # 一千萬 inode

# 格式化時指定更大日志（最大 1024 塊組，通常 4GB）
sudo mkfs.ext4 -J size=4096 /dev/sdd1

# 查看當(dāng)前內(nèi)核支持的 ext4 特性
cat /proc/filesystems | grep ext4
modinfo ext4

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.*;
import java.util.concurrent.TimeUnit;
public class Ext4PerformanceBenchmark {
    private static final int FILE_SIZE = 100 * 1024 * 1024; // 100MB
    private static final int CHUNK_SIZE = 8192;
    public static void testBufferedWrite(Path file) throws IOException {
        long start = System.nanoTime();
        try (BufferedWriter writer = Files.newBufferedWriter(file)) {
            byte[] chunk = new byte[CHUNK_SIZE];
            for (int i = 0; i < FILE_SIZE / CHUNK_SIZE; i++) {
                writer.write(new String(chunk));
            }
        }
        long end = System.nanoTime();
        System.out.printf("??  Buffered Write: %.2f ms%n", 
            TimeUnit.NANOSECONDS.toMillis(end - start));
    }
    public static void testChannelWrite(Path file) throws IOException {
        long start = System.nanoTime();
        try (FileChannel channel = FileChannel.open(file, 
                StandardOpenOption.WRITE, 
                StandardOpenOption.CREATE,
                StandardOpenOption.TRUNCATE_EXISTING)) {
            ByteBuffer buffer = ByteBuffer.allocate(CHUNK_SIZE);
            for (int i = 0; i < FILE_SIZE / CHUNK_SIZE; i++) {
                buffer.clear();
                buffer.put(("Chunk" + i + "\n").getBytes());
                buffer.flip();
                while (buffer.hasRemaining()) {
                    channel.write(buffer);
                }
            }
        }
        long end = System.nanoTime();
        System.out.printf("? Channel Write: %.2f ms%n", 
            TimeUnit.NANOSECONDS.toMillis(end - start));
    }
    public static void testPreallocatedWrite(Path file) throws IOException {
        long start = System.nanoTime();
        try (FileChannel channel = FileChannel.open(file, 
                StandardOpenOption.WRITE, 
                StandardOpenOption.CREATE)) {
            // 預(yù)分配
            channel.truncate(FILE_SIZE);
            ByteBuffer buffer = ByteBuffer.allocate(CHUNK_SIZE);
            for (int i = 0; i < FILE_SIZE / CHUNK_SIZE; i++) {
                buffer.clear();
                buffer.put(("Chunk" + i + "\n").getBytes());
                buffer.flip();
                while (buffer.hasRemaining()) {
                    channel.write(buffer);
                }
            }
        }
        long end = System.nanoTime();
        System.out.printf("?? Preallocated Write: %.2f ms%n", 
            TimeUnit.NANOSECONDS.toMillis(end - start));
    }
    public static void main(String[] args) {
        Path basePath = Paths.get("/tmp/ext4_bench");
        try {
            Files.createDirectories(basePath);
        } catch (IOException ignored) {}
        Path file1 = basePath.resolve("buffered.dat");
        Path file2 = basePath.resolve("channel.dat");
        Path file3 = basePath.resolve("prealloc.dat");
        System.out.println("?? 開始 ext4 寫入性能測試...");
        try {
            testBufferedWrite(file1);
            testChannelWrite(file2);
            testPreallocatedWrite(file3);
        } catch (IOException e) {
            System.err.println("測試失敗: " + e.getMessage());
        }
        System.out.println("? 測試完成。請結(jié)合 iostat 分析實際磁盤行為。");
    }
}

mount | grep /tmp
# 若不是，可創(chuàng)建專用測試目錄：
sudo mkdir /mnt/ext4_test
sudo mount -o remount,noatime /dev/sdXN /mnt/ext4_test