本章深入探讨Go语言文件处理与IO操作的核心技术，结合高性能实践与安全规范，提供企业级解决方案。

11.1 文件读写

11.1.1 基础操作

// 全量读取（小文件适用）
data, err := os.ReadFile("data.txt")
if err != nil {
    log.Fatal(err)
}

// 分块读取（大文件优化）
file, err := os.Open("large.log")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

buf := make([]byte, 64*1024) // 64KB块
for {
    n, err := file.Read(buf)
    if n > 0 {
        process(buf[:n])
    }
    if errors.Is(err, io.EOF) {
        break
    }
}

11.1.2 原子写入

// 临时文件替换模式
func safeWrite(filename string, data []byte) error {
    tmp := filename + ".tmp"
    if err := os.WriteFile(tmp, data, 0644); err != nil {
        return err
    }
    return os.Rename(tmp, filename)  // 原子操作
}

注意事项

• 使用O_SYNC标志确保数据落盘（牺牲性能换取安全）
• 跨平台路径处理使用filepath.Join()
• 文件权限设置遵循最小权限原则（如0600）

11.2 缓冲区处理

11.2.1 高效缓冲策略

// 复用缓冲区池
var bufPool = sync.Pool{
    New: func() interface{} {
        return bytes.NewBuffer(make([]byte, 0, 4096))
    },
}

func processFile() {
    buf := bufPool.Get().(*bytes.Buffer)
    defer bufPool.Put(buf)
    buf.Reset()

    _, _ = buf.ReadFrom(file)
    // 处理数据
}

11.2.2 bufio高级用法

reader := bufio.NewReaderSize(file, 1<<20) // 1MB缓冲
writer := bufio.NewWriterSize(os.Stdout, 8192)

// 自定义扫描分割符
scanner := bufio.NewScanner(file)
scanner.Split(func(data []byte, atEOF bool) (advance int, token []byte, err error) {
    // 自定义分割逻辑
})

性能对比

11.3 目录操作

11.3.1 高效遍历

// 使用WalkDir提升性能（Go 1.16+）
err := filepath.WalkDir("logs", func(path string, d fs.DirEntry, err error) error {
    if d.IsDir() && d.Name() == "tmp" {
        return filepath.SkipDir  // 跳过目录
    }
    if !d.Type().IsRegular() {
        return nil
    }
    processFile(path)
    return nil
})

11.3.2 并发清理

func cleanDir(dir string) {
    entries, _ := os.ReadDir(dir)
    var wg sync.WaitGroup
    sem := make(chan struct{}, 8) // 并发控制

    for _, e := range entries {
        wg.Add(1)
        sem <- struct{}{}
        go func(name string) {
            defer func() { <-sem; wg.Done() }()
            os.Remove(filepath.Join(dir, name))
        }(e.Name())
    }
    wg.Wait()
}

11.4 文件监控

11.4.1 使用fsnotify库

watcher, _ := fsnotify.NewWatcher()
defer watcher.Close()

// 添加监控路径
watcher.Add("/var/log")

go func() {
    for {
        select {
        case event, ok := <-watcher.Events:
            if !ok {
                return
            }
            handleFileEvent(event)
        case err, ok := <-watcher.Errors:
            if !ok {
                return
            }
            log.Println("watch error:", err)
        }
    }
}()

11.4.2 生产级监控方案

func handleFileEvent(e fsnotify.Event) {
    switch {
    case e.Op&fsnotify.Write == fsnotify.Write:
        log.Println("Modified:", e.Name)
    case e.Op&fsnotify.Create == fsnotify.Create:
        if isDir(e.Name) {
            watcher.Add(e.Name) // 监控新子目录
        }
    case e.Op&fsnotify.Remove == fsnotify.Remove:
        watcher.Remove(e.Name)
    }
}

11.5 序列化与反序列化

11.5.1 高性能JSON处理

// 使用jsoniter替代标准库
import jsoniter "github.com/json-iterator/go"

var json = jsoniter.ConfigCompatibleWithStandardLibrary

func fastMarshal(v interface{}) ([]byte, error) {
    stream := jsoniter.NewStream(jsoniter.ConfigDefault, nil, 0)
    stream.WriteVal(v)
    return stream.Buffer(), stream.Error
}

11.5.2 二进制序列化

// 使用gob编码
func encodeToBinary(v interface{}) ([]byte, error) {
    var buf bytes.Buffer
    enc := gob.NewEncoder(&buf)
    if err := enc.Encode(v); err != nil {
        return nil, err
    }
    return buf.Bytes(), nil
}

// 自定义二进制协议
type Header struct {
    Version [4]byte
    Length  uint32
}

格式对比

总结

本章系统构建了Go语言文件处理的知识体系，关键要点包括：

1. 零拷贝技术在文件传输中的高效实现
2. 缓冲池模式对IO密集型应用的性能提升
3. 原子文件操作保障数据一致性
4. 实时监控方案的工程化部署
5. 序列化协议选型的综合评估方法

安全实践指南：

• 文件路径始终使用filepath.Clean()规范化
• 反序列化前验证数据来源与签名
• 设置文件描述符限制（ulimit -n）
• 敏感文件设置内存锁定（syscall.Mlock）

建议通过以下场景巩固技能：

• 实现一个支持断点续传的文件传输服务
• 开发实时日志分析监控系统
• 对比不同序列化协议在百万级数据下的性能表现
• 构建安全的配置文件热加载机制