From unique to cleanups and weak new low-level tools for efficiency

package main

import (
 "os"
 "runtime"
 "syscall"
)

// MemoryMappedFile 表示一个内存映射文件对象
// 通过该对象可直接访问文件内容，无需反复读取磁盘
// 当对象不再使用时，会自动释放内存映射资源
type MemoryMappedFile struct {
    data []byte // 文件内容的内存映射区域
}

// NewMemoryMappedFile 创建一个内存映射文件对象
// filename: 需要被映射的文件路径
func NewMemoryMappedFile(filename string) (*MemoryMappedFile, error) {
    // 打开指定文件
    f, err := os.Open(filename)
    if err != nil {
        return nil, err
    }
    // 确保函数结束时自动关闭文件句柄
    defer f.Close()

    // 获取文件信息（主要是为了获取文件大小）
    fi, err := f.Stat()
    if err != nil {
        return nil, err
    }

    // 获取底层系统的文件描述符（file descriptor）
    conn, err := f.SyscallConn()
    if err != nil {
        return nil, err
    }

    var data []byte
    // 使用conn.Control安全地拿到文件描述符并执行内存映射操作
    connErr := conn.Control(func(fd uintptr) {
    // syscall.Mmap 将文件内容映射到内存
    data, err = syscall.Mmap(
        int(fd),            // 文件描述符
        0,                  // 映射的起始位置，从文件头开始
        int(fi.Size()),     // 映射的长度为文件的大小
        syscall.PROT_READ,  // 映射区域权限：只读
        syscall.MAP_SHARED, // 共享模式，可被多个进程访问
    )
    })

    // 检查映射过程中是否发生错误
    if connErr != nil || err != nil {
        return nil, err
    }

    // 创建内存映射文件对象
    mf := &MemoryMappedFile{data: data}

    // 定义清理函数，用于释放内存映射资源
    cleanup := func(data []byte) {
        syscall.Munmap(data) // 当对象被垃圾回收时，自动解除内存映射
    }

    // 添加清理函数，当 mf 对象不再被引用时，自动调用 cleanup
    runtime.AddCleanup(mf, cleanup, data)

    return mf, nil
}

var cache sync.Map // 缓存文件映射: map[string]weak.Pointer[MemoryMappedFile]

func NewCachedMemoryMappedFile(filename string) (*MemoryMappedFile, error) {
    var newFile *MemoryMappedFile
    for {
        value, ok := cache.Load(filename)
        if !ok {
            if newFile == nil {
                var err error
                newFile, err = NewMemoryMappedFile(filename)
                if err != nil {
                    return nil, err
                }
            }

            wp := weak.Make(newFile)
            value, loaded := cache.LoadOrStore(filename, wp)
            if !loaded {
                runtime.AddCleanup(newFile, func(filename string) {
                    cache.CompareAndDelete(filename, wp)
                }, filename)
                return newFile, nil
            }
        }

        if mf := value.(weak.Pointer[MemoryMappedFile]).Value(); mf != nil {
            return mf, nil
        }

        cache.CompareAndDelete(filename, value)
    }
}

type Cache[K comparable, V any] struct {
    create func(K) (*V, error)
    m      sync.Map
}

func (c *Cache[K, V]) Get(key K) (*V, error) {
    var newValue *V
    for {
        value, ok := c.m.Load(key)
        if !ok {
            if newValue == nil {
                var err error
                newValue, err = c.create(key)
                if err != nil {
                    return nil, err
                }
            }

            wp := weak.Make(newValue)
            value, loaded := c.m.LoadOrStore(key, wp)
            if !loaded {
                runtime.AddCleanup(newValue, func(key K) {
                    c.m.CompareAndDelete(key, wp)
                }, key)
                return newValue, nil
            }
        }

        if v := value.(weak.Pointer[V]).Value(); v != nil {
            return v, nil
        }

        c.m.CompareAndDelete(key, value)
    }
}