CGO分配内存时Finalizer过早调用致段错误，求正确用法

问题根源 #

你遇到的核心问题是Finalizer绑定的对象错误：

• 在allocate函数中，你给局部变量godata的地址设置了Finalizer，但godata是函数内的局部切片变量，当函数返回后，这个局部变量的内存（仅包含切片的元数据：指针、长度、容量）不再被任何代码引用，Go的GC会认为它可以被回收，因此立即触发Finalizer释放了C分配的内存。
• 你返回的dummy.Data只是复制了godata的切片元数据，它和原godata指向同一块C内存，但Finalizer并没有绑定到dummy实例或dummy.Data上，所以当局部的godata被回收时，C内存就被提前释放，后续访问dummy.Data自然会触发段错误。

正确解决方案 #

方案1：将Finalizer绑定到返回的结构体实例

把Finalizer绑定到dummy结构体实例上，只要dummy在代码中还被引用，Finalizer就不会触发。同时建议在结构体中保存原始的C指针，避免依赖切片的底层指针：

package main

/*
#include <stdlib.h>

unsigned char* allocate(int size) {
  return (unsigned char*)malloc(size);
}

void free_allocated(unsigned char *c) {
  free(c);
}
*/
import "C"
import (
    "runtime"
    "time"
    "unsafe"
)

type dummy struct {
    Data []uint8
    cPtr unsafe.Pointer // 保存原始C内存指针，确保释放时不会丢失
}

func allocate(size int) *dummy {
    cPtr := C.allocate((C.int)(size))
    godata := unsafe.Slice((*uint8)(cPtr), size)
    d := &dummy{
        Data: godata,
        cPtr: cPtr,
    }
    // 将Finalizer绑定到dummy实例，而非局部变量
    runtime.SetFinalizer(d, func(obj *dummy) {
        println("Freeing")
        C.free_allocated(obj.cPtr)
    })
    return d
}

func main() {
    println("Start")

    dummy := allocate(1_000_000_000)
    dummy.Data[100_000_000] = 1

    println("Allocated")

    println("GC")
    runtime.GC()

    println("Waiting 10 seconds")
    <-time.After(10 * time.Second)

    // 此时dummy仍被引用，Finalizer未触发，内存正常可用
    println("Value is: ", dummy.Data[100_000_000])
}

方案2：直接返回切片时绑定Finalizer到载体对象

如果不需要结构体封装，可以创建一个专门的载体对象来绑定Finalizer，确保载体对象和切片的生命周期一致：

func allocate(size int) []uint8 {
    cPtr := C.allocate((C.int)(size))
    godata := unsafe.Slice((*uint8)(cPtr), size)
    // 创建载体对象，绑定Finalizer
    carrier := new(struct{})
    runtime.SetFinalizer(carrier, func(_ *struct{}) {
        println("Freeing")
        C.free_allocated(cPtr)
    })
    // 通过runtime.KeepAlive确保载体对象与切片生命周期绑定
    runtime.KeepAlive(godata, carrier)
    return godata
}

关键注意事项 #

• Finalizer必须绑定到长期存活的对象：不能绑定到局部变量，局部变量在函数返回后会失去引用，被GC快速回收。
• 保留原始C指针：不要依赖切片的底层指针来释放内存，因为切片可能被重新切片、截断或修改，导致无法正确获取原始指针。
• 避免Finalizer依赖临时对象：任何被Finalizer引用的对象都需要确保在Finalizer执行前不会被回收，否则可能导致未定义行为。

内容的提问来源于stack exchange，提问作者Wendelin