Go语言内存映射文件与数据持久化：RDWR模式下的Flush机制解析

package main

import (
    "fmt"
    "io/ioutil"
    "os"
    "syscall" // For mmap constants and functions, or use a library like "github.com/edsrzf/mmap-go"
)

// Simplified MMap interface for demonstration
type MMap []byte

// Map creates a new memory mapping.
// In a real scenario, you'd use a robust mmap library or direct syscalls.
func Map(file *os.File, prot, offset int) (MMap, error) {
    // This is a simplified placeholder.
    // A real implementation would involve syscall.Mmap
    // For demonstration, let's assume a fixed size for simplicity.
    // In a real mmap, size would be derived from file info.
    fileInfo, err := file.Stat()
    if err != nil {
        return nil, fmt.Errorf("could not get file info: %w", err)
    }
    size := int(fileInfo.Size())
    if size == 0 { // Handle empty files if necessary
        size = 4096 // Or some default/initial size
    }

    // Using syscall.Mmap directly for illustration
    data, err := syscall.Mmap(int(file.Fd()), int64(offset), size, prot, syscall.MAP_SHARED)
    if err != nil {
        return nil, fmt.Errorf("mmap failed: %w", err)
    }
    return MMap(data), nil
}

// Flush writes any modified pages in the MMap object to the underlying file.
func (m MMap) Flush() error {
    // In a real library, this would be a call to msync.
    // For demonstration, we simulate the effect using syscall.Msync
    return syscall.Msync(m, syscall.MS_SYNC)
}

// Unmap unmaps the memory region.
func (m MMap) Unmap() error {
    return syscall.Munmap(m)
}


func main() {
    // 1. 创建一个测试文件
    fileName := "testfile.txt"
    content := []byte("Hello, mmap world!")
    err := ioutil.WriteFile(fileName, content, 0644)
    if err != nil {
        fmt.Printf("Error creating file: %v\n", err)
        return
    }
    defer os.Remove(fileName) // 确保测试文件被清理

    // 2. 打开文件
    f, err := os.OpenFile(fileName, os.O_RDWR, 0644)
    if err != nil {
        fmt.Printf("Error opening file: %v\n", err)
        return
    }
    defer f.Close()

    // 3. 映射文件到内存 (RDWR模式)
    // 在实际应用中，prot参数会根据RDWR模式设置
    // syscall.PROT_READ | syscall.PROT_WRITE 对应 RDWR
    mmapData, err := Map(f, syscall.PROT_READ|syscall.PROT_WRITE, 0)
    if err != nil {
        fmt.Printf("Error mapping file: %v\n", err)
        return
    }
    defer mmapData.Unmap() // 确保解除映射

    fmt.Printf("Original mmap content: %s\n", string(mmapData))

    // 4. 修改映射内存中的数据
    if len(mmapData) > 9 {
        mmapData[9] = 'X'
        fmt.Printf("Modified mmap content (in memory): %s\n", string(mmapData))
    } else {
        fmt.Println("Mmap data too short to modify at index 9.")
        return
    }


    // 5. 在不调用Flush的情况下，尝试读取文件内容
    // 为了演示效果，这里需要重新打开文件或使用另一个文件描述符
    // 否则，同一个文件描述符可能仍然看到内存中的最新修改
    // 最佳实践是关闭当前文件描述符，再用另一个描述符打开读取
    f.Seek(0, 0) // 重置文件读取位置
    // 注意：在某些OS或文件系统上，即使不Flush，后续的read也可能立即看到修改
    // 但这并非POSIX标准保证的行为，因此Flush仍然是必要的。
    fileContentBeforeFlush, _ := ioutil.ReadAll(f)
    fmt.Printf("File content before Flush (read via f): %s\n", string(fileContentBeforeFlush))


    // 6. 调用 Flush 确保修改写入文件
    err = mmapData.Flush()
    if err != nil {
        fmt.Printf("Error flushing mmap: %v\n", err)
        return
    }
    fmt.Println("Mmap flushed successfully.")

    // 7. 再次读取文件内容，确认修改已持久化
    f.Seek(0, 0) // 重置文件读取位置
    fileContentAfterFlush, err := ioutil.ReadAll(f)
    if err != nil {
        fmt.Printf("Error reading file after flush: %v\n", err)
        return
    }
    fmt.Printf("File content after Flush (read via f): %s\n", string(fileContentAfterFlush))

    // 8. 验证
    expected := "Hello, mmapXorld!"
    if string(fileContentAfterFlush) == expected {
        fmt.Println("Verification successful: File content matches expected after flush.")
    } else {
        fmt.Printf("Verification failed: Expected '%s', got '%s'\n", expected, string(fileContentAfterFlush))
    }
}