Linux中ext4文件系统的工作原理和优化策略

# 将 ext3 升级为 ext4（需先卸载分区）
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

# 推荐用于数据库/日志服务器
/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 类似功能预分配空间
        try (FileChannel channel = FileChannel.open(filePath, 
                StandardOpenOption.WRITE, 
                StandardOpenOption.CREATE)) {
            // 预分配空间，减少后续碎片
            channel.truncate(fileSize);
            // 写入数据
            ByteBuffer buffer = ByteBuffer.allocate(8192);
            for (int i = 0; i < fileSize / buffer.capacity(); i++) {
                buffer.clear();
                // 填充数据...
                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("✅ 文件写入完成，已预分配空间");
        } 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)) {
            // 内存映射文件 —— OS 自动管理缓存
            MappedByteBuffer buffer = channel.map(
                FileChannel.MapMode.READ_WRITE, 0, 1024 * 1024);
            buffer.put("Hello from memory-mapped world!".getBytes());
            buffer.force(); // 强制刷盘
            System.out.println("💾 数据已通过内存映射写入");
        }
    }
}

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(); // 强制刷盘，破坏延迟分配
            }
        }
    }
    // ✅ 高效：批量写入 + 大缓冲区
    public static void goodPractice(Path file) throws IOException {
        // 使用 128KB 缓冲区
        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，触发一次延迟分配
        }
        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()) {
            // 建议内核预读 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("📈 文件预热完成，提升后续顺序读取性能");
        }
    }
}

# 每2秒刷新一次，关注 %util 和 await
iostat -x 2

# 跟踪 sda 设备的 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

# 设置预留空间为 1%
sudo tune2fs -m 1 /dev/sdb1

# 启用 project quota（项目配额）
sudo tune2fs -O project /dev/sdb1

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

# 强制检查（需卸载分区）
sudo umount /dev/sdb1
sudo e2fsck -f /dev/sdb1
sudo mount /dev/sdb1 /mnt/data

# 应返回 "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

# 重启相关进程或 kill -HUP 释放

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

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

# 查看当前内核支持的 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)) {
            // 预分配
            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("✅ 测试完成。请结合 iostat 分析实际磁盘行为。");
    }
}

mount | grep /tmp
# 若不是，可创建专用测试目录：
sudo mkdir /mnt/ext4_test
sudo mount -o remount,noatime /dev/sdXN /mnt/ext4_test