深入理解Go切片与大索引内存效率

type SliceHeader struct {
    Data uintptr // 指向底层数组的指针
    Len  int     // 切片的长度
    Cap  int     // 切片的容量
}

package main

import "fmt"

func main() {
    a := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    b := a[2:8] // 从索引2到7创建新切片
    c := a[8:]  // 从索引8到末尾创建新切片
    d := b[2:4] // 从b的索引2到3创建新切片

    fmt.Printf("a: %v, len: %d, cap: %d\n", a, len(a), cap(a))
    fmt.Printf("b: %v, len: %d, cap: %d\n", b, len(b), cap(b))
    fmt.Printf("c: %v, len: %d, cap: %d\n", c, len(c), cap(c))
    fmt.Printf("d: %v, len: %d, cap: %d\n", d, len(d), cap(d))

    // 观察底层数组的变化（通过修改切片元素）
    b[0] = 99 // 改变b的第一个元素，实际上是改变a的第三个元素
    fmt.Printf("a (after b[0]=99): %v\n", a)
}

a: [0 1 2 3 4 5 6 7 8 9], len: 10, cap: 10
b: [2 3 4 5 6 7], len: 6, cap: 8
c: [8 9], len: 2, cap: 2
d: [4 5], len: 2, cap: 6
a (after b[0]=99): [0 1 99 3 4 5 6 7 8 9]

func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error)

package main

import (
    "fmt"
    "io/ioutil"
    "os"
    "syscall"
)

// mmap 将文件的指定部分映射到内存并返回一个字节切片
func mmap(fd *os.File, startOffset int64, size int) ([]byte, error) {
    // 确保文件指针在起始位置，虽然Mmap会使用指定的offset
    // 但为了代码健壮性，这里可以seek一下
    _, err := fd.Seek(0, 0)
    if err != nil {
        return nil, err
    }

    // syscall.Mmap 将文件描述符fd的startOffset开始的size字节映射到内存
    // PROT_READ 表示只读访问
    // MAP_SHARED 表示映射是共享的，对内存区域的修改会反映到文件中
    return syscall.Mmap(int(fd.Fd()), startOffset, size,
        syscall.PROT_READ, syscall.MAP_SHARED)
}

func main() {
    // 1. 创建一个测试文件并写入一些数据
    fileName := "testfile.data"
    data := []byte("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
    err := ioutil.WriteFile(fileName, data, 0644)
    if err != nil {
        fmt.Println("Error writing file:", err)
        return
    }
    fmt.Printf("Created file '%s' with content: %s\n", fileName, data)

    // 2. 打开文件
    file, err := os.Open(fileName)
    if err != nil {
        fmt.Println("Error opening file:", err)
        return
    }
    defer file.Close() // 确保文件关闭

    // 3. 使用mmap映射文件的一部分
    // 假设我们只想访问文件从索引10 ('K') 开始的5个字节
    offset := int64(10) // 从索引10开始
    length := 5         // 映射5个字节

    // 映射文件内容
    mappedSlice, err := mmap(file, offset, length)
    if err != nil {
        fmt.Println("Error mmapping file:", err)
        return
    }

    // 4. 使用完毕后，务必解除内存映射
    defer func() {
        err := syscall.Munmap(mappedSlice)
        if err != nil {
            fmt.Println("Error unmapping memory:", err)
        } else {
            fmt.Println("Memory unmapped successfully.")
        }
    }()

    // 5. 访问映射的切片
    fmt.Printf("Mapped slice (len %d, cap %d): %s\n", len(mappedSlice), cap(mappedSlice), mappedSlice)
    fmt.Printf("Mapped slice element at index 0: %c\n", mappedSlice[0]) // 对应文件中的'K'
    fmt.Printf("Mapped slice element at index 1: %c\n", mappedSlice[1]) // 对应文件中的'L'

    // 清理测试文件
    os.Remove(fileName)
}

Created file 'testfile.data' with content: ABCDEFGHIJKLMNOPQRSTUVWXYZ
Mapped slice (len 5, cap 5): KLMNO
Mapped slice element at index 0: K
Mapped slice element at index 1: L
Memory unmapped successfully.