Go语言中禁用GC后的内存手动释放：CGO与runtime·free的实践

// package mem
package mem

import (
    "reflect"
    "unsafe"
)

// FreePtr 是一个外部Go函数，它通过CGO调用C语言的内存释放函数。
// 实际的内存释放逻辑在C代码中实现。
func FreePtr(p unsafe.Pointer)

// Free 接收一个Go接口类型的值，并尝试释放其底层内存。
// 注意：此函数仅适用于通过make分配的、且其底层指针可以通过reflect获取的类型（如切片、映射等）。
// 它通过反射获取值的底层指针，然后调用FreePtr进行释放。
func Free(v interface{}) {
    // 获取v的反射值
    val := reflect.ValueOf(v)
    // 确保v是一个指针，并且其指向的元素是可寻址的
    if val.Kind() == reflect.Ptr && val.Elem().CanAddr() {
        // 获取底层元素的指针，并转换为unsafe.Pointer
        FreePtr(unsafe.Pointer(val.Elem().UnsafeAddr()))
    } else if val.Kind() == reflect.Slice || val.Kind() == reflect.Map || val.Kind() == reflect.Chan {
        // 对于切片、映射、通道等，直接获取其数据指针
        // 注意：这可能需要更复杂的逻辑来确保正确获取和释放底层数据结构
        // 这里的示例是针对切片，直接获取其底层数组的指针
        // 对于切片，其底层数据结构通常是连续的内存块
        if val.Len() > 0 {
            FreePtr(unsafe.Pointer(val.Index(0).UnsafeAddr()))
        }
    } else {
        // 对于其他类型，可能无法安全地通过这种方式释放内存
        // 或者需要更具体的处理逻辑
        panic("mem.Free: unsupported type or cannot obtain address")
    }
}

// +build gc

// 引入Go运行时头文件，以便访问内部函数
#include <runtime.h>

// 声明Go内部的runtime·free函数
// 这里的函数签名需要与Go运行时内部的实际签名匹配
// 在Go的内部实现中，runtime·free通常接收一个void*类型的指针
extern void runtime·free(void*);

// 这是Go代码通过CGO调用的C函数
// 注意Go和C函数名的映射规则：Go的FreePtr映射到C的_cgo_FreePtr，
// 而这里我们直接定义一个C函数来调用runtime·free
// 更好的做法是让Go的FreePtr直接调用一个C函数，例如FreeGoMemory，
// 然后FreeGoMemory再调用runtime·free。
// 考虑到原始答案的写法，我们保持其结构，但需要明确Go和C的交互。

// Go函数 `mem.FreePtr` 将会通过CGO机制映射到此C函数。
// Go编译器会为 `func FreePtr(p unsafe.Pointer)` 生成一个CGO包装器，
// 该包装器会调用一个名为 `_cgo_mem_FreePtr` 的C函数（或类似名称），
// 而这个C函数需要我们在这里实现，并最终调用 `runtime·free`。
// 原始答案的写法 `void ·Free(void* foo)` 似乎是Go内部C文件的特殊语法。
// 对于外部CGO，我们需要一个标准的C函数名。

// 假设Go的FreePtr函数通过CGO调用名为 `freeGoMemory` 的C函数。
// Go代码中的 `func FreePtr(p unsafe.Pointer)` 实际上声明了一个C函数 `freeGoMemory`。
void freeGoMemory(void* ptr) {
    runtime·free(ptr);
}

package mem

import (
    "reflect"
    "unsafe"
)

//go:linkname runtime_free runtime.free
func runtime_free(p unsafe.Pointer) // 声明Go运行时内部的free函数

// FreePtr 直接调用链接到的runtime.free
func FreePtr(p unsafe.Pointer) {
    runtime_free(p)
}

// Free 保持不变
func Free(v interface{}) {
    // ... (同上)
    val := reflect.ValueOf(v)
    if val.Kind() == reflect.Ptr && val.Elem().CanAddr() {
        FreePtr(unsafe.Pointer(val.Elem().UnsafeAddr()))
    } else if val.Kind() == reflect.Slice { // 只处理切片
        if !val.IsNil() && val.Len() > 0 {
            // 获取切片底层数组的第一个元素的地址
            FreePtr(unsafe.Pointer(val.Index(0).UnsafeAddr()))
        }
    } else {
        panic("mem.Free: unsupported type or cannot obtain address")
    }
}

// +build gc

#include <stdlib.h> // 包含malloc/free等标准C库函数，虽然这里调用的是Go的runtime·free
// 注意：<runtime.h> 是Go内部头文件，通常不直接给外部CGO使用。
// 如果要访问Go内部符号，通常需要特殊的编译设置或通过Go的linkname。
// 原始答案的<runtime.h>和runtime·free调用表明它意图访问Go内部符号。
// 对于外部CGO，我们需要一个Go能调用的C函数。

// 声明Go内部的runtime·free函数。
// 这通常需要特殊的编译和链接选项才能在外部C文件中访问Go内部符号。
// 假设在特定编译环境下，Go的runtime·free符号可以通过C代码访问。
// 实际操作中，这可能需要修改Go的toolchain或使用非常规方法。
// 这里的实现是基于原始答案的假设。
extern void runtime_free(void*); // 假设Go内部的free函数符号名为runtime_free

// CGO调用的C函数，与Go的FreePtr函数对应
// Go代码中声明 `func FreePtr(p unsafe.Pointer)`
// CGO会将其映射为 C 函数 `_cgo_mem_FreePtr` （具体名称可能因Go版本和包名而异）
// 我们需要实现这个C函数来调用 Go 的 runtime_free
void _cgo_mem_FreePtr(void* p) {
    runtime_free(p);
}

// 原始答案的写法 `void ·Free(void* foo)` 是一种Go内部C文件的特殊语法。
// 对于外部CGO，我们需要使用标准C函数名。
// 为了兼容原始答案，假设 `mem.FreePtr` 最终会调用一个C函数，
// 而这个C函数内部再调用 Go 的 `runtime_free`。
// 上面的 `_cgo_mem_FreePtr` 是一个更标准的CGO映射示例。

package mem

import (
    "reflect"
    "unsafe"
)

//go:linkname runtime_free runtime.free
// runtime_free 声明了Go运行时内部的内存释放函数。
// 使用 //go:linkname 指令将其链接到Go运行时实际的 `runtime.free` 符号。
// 这使得我们可以在Go代码中直接调用Go运行时内部的内存释放机制。
func runtime_free(p unsafe.Pointer)

// FreePtr 直接调用链接到的runtime_free函数，执行内存去分配。
func FreePtr(p unsafe.Pointer) {
    if p != nil {
        runtime_free(p)
    }
}

// Free 接收一个Go接口类型的值，并尝试释放其底层内存。
// 此函数通过反射获取值的底层指针，然后调用FreePtr进行释放。
// 注意：此方法应谨慎使用，仅适用于明确知道其内存结构且由Go运行时分配的类型。
func Free(v interface{}) {
    val := reflect.ValueOf(v)
    if val.Kind() == reflect.Ptr && val.Elem().CanAddr() {
        // 对于指针类型，释放其指向的内存
        FreePtr(unsafe.Pointer(val.Elem().UnsafeAddr()))
    } else if val.Kind() == reflect.Slice {
        // 对于切片，释放其底层数组的内存
        // 注意：如果切片是 nil 或长度为 0，则无需释放
        if !val.IsNil() && val.Len() > 0 {
            // 获取切片底层数组的第一个元素的地址
            FreePtr(unsafe.Pointer(val.Index(0).UnsafeAddr()))
        }
    } else {
        // 对于其他类型，可能无法安全地通过这种方式释放内存
        // 或者需要更具体的处理逻辑。
        // 强制释放非指针或非切片类型的内存可能导致运行时错误或内存损坏。
        panic("mem.Free: unsupported type for direct memory deallocation")
    }
}

package main

import (
    "fmt"
    "runtime"
    // 假设你的mem包位于模块根目录下的free/mem
    "your_module_path/free/mem" // 根据你的go module路径调整
)

func main() {
    var m1, m2 runtime.MemStats

    // 第一次读取内存统计信息
    runtime.ReadMemStats(&m1)
    fmt.Printf("Initial Frees: %d\n", m1.Frees)

    // 分配一个大的切片
    c := make([]int, 10000) // 分配10000个int的内存
    fmt.Printf("Allocated slice of %d ints. First element address: %p\n", len(c), &c[0])

    // 手动释放切片c的底层内存
    // 注意：释放后不应再访问c的元素，否则会导致内存错误
    mem.Free(&c)
    fmt.Println("Memory for slice 'c' explicitly freed.")

    // 第二次读取内存统计信息
    runtime.ReadMemStats(&m2)
    fmt.Printf("Frees after deallocation: %d\n", m2.Frees)

    // 比较两次Frees计数，验证内存释放是否成功
    fmt.Printf("Difference in Frees: %d (Expected: 1)\n", m2.Frees-m1.Frees)

    // 尝试访问已释放的内存将导致运行时错误
    // fmt.Println(c[0]) // 危险操作，可能导致崩溃
}