Go CGO与内存管理：解决C回调结构体在Go垃圾回收中失效的问题

// 原始问题中的函数示例 (存在潜在问题)
func createNewEventHandler() *C.vde_event_handler {
    var libevent_eh C.vde_event_handler // 在Go栈上分配，但返回指针后，若无Go变量持有，则可能被GC
    // ... 初始化 libevent_eh 的字段 ...
    return &libevent_eh // 返回局部变量的地址，这是Go和C中都应避免的
}

package main

/*
#include <stdio.h>
#include <stdlib.h> // For malloc/free if needed

// 假设的 C 语言事件处理器结构体
typedef struct vde_event_handler {
    void (*event_add)(void*);
    void (*event_del)(void*);
    void (*timeout_add)(void*);
    void (*timeout_del)(void*);
} vde_event_handler;

// 假设的 C 语言上下文结构体
typedef struct vde_context {
    // ... 其他字段 ...
    vde_event_handler* handler; // C 库持有事件处理器的指针
} vde_context;

// 假设的 C 库初始化函数
// 实际库函数可能更复杂，这里仅作示意
void VdeContext_Init(vde_context* ctx, vde_event_handler* handler) {
    if (ctx) {
        ctx->handler = handler;
        // 实际库函数会在这里使用 handler 来设置事件回调
        printf("C: VdeContext initialized with handler at %p\n", (void*)handler);
    }
}

// 假设的 C 库使用事件处理器的函数
void VdeContext_UseHandler(vde_context* ctx) {
    if (ctx && ctx->handler && ctx->handler->event_add) {
        printf("C: Using handler's event_add function at %p\n", (void*)ctx->handler->event_add);
        // ctx->handler->event_add(NULL); // 实际调用
    } else {
        printf("C: Handler or its functions are NULL!\n");
    }
}

// 假设的 C 库清理函数
void VdeContext_Free(vde_context* ctx) {
    if (ctx) {
        printf("C: VdeContext freed.\n");
        free(ctx); // 假设 ctx 是用 C.malloc 分配的
    }
}

*/
import "C"
import (
    "fmt"
    "runtime"
    "unsafe"
)

// VdeContext 是一个Go结构体，用于封装C库的vde_context和相关的Go资源。
type VdeContext struct {
    cContext     *C.vde_context      // C库的上下文指针
    eventHandler *C.vde_event_handler // Go代码持有对CGO事件处理器的引用
    // 如果 eventHandler 内部的函数指针指向Go函数，
    // 那么这些Go函数也需要通过 go:export 导出，并确保其生命周期。
    // 这里我们假设 eventHandler 的字段是C函数指针。
}

// createNewEventHandler 负责在Go堆上创建并初始化 C.vde_event_handler。
// 它返回一个指针，这个指针需要被Go代码持有。
func createNewEventHandler() *C.vde_event_handler {
    // 在Go堆上分配 C.vde_event_handler 结构体。
    // 只要有Go变量持有这个指针，它就不会被Go GC回收。
    eh := &C.vde_event_handler{}

    // 假设这些是C库提供的函数指针，或者通过Go包装器导出给C的Go函数指针。
    // 这里我们模拟它们被正确赋值。
    // 注意：实际的函数指针赋值需要确保这些Go函数通过 go:export 机制正确导出，
    // 并且 CGO 能够获取到它们的C语言函数指针。
    // eh.event_add = C.some_c_event_add_func // 假设 C 库提供
    // eh.event_del = C.some_c_event_del_func // 假设 C 库提供
    // ...

    fmt.Printf("Go: New event handler created at %p\n", unsafe.Pointer(eh))
    return eh
}

// NewVdeContext 初始化并返回一个 VdeContext 实例。
func NewVdeContext() *VdeContext {
    ctx := &VdeContext{}

    // 1. 在Go中创建并持有 eventHandler 的引用
    ctx.eventHandler = createNewEventHandler()

    // 2. 分配C库的上下文（假设需要C.malloc）
    ctx.cContext = (*C.vde_context)(C.malloc(C.sizeof_struct_vde_context))
    if ctx.cContext == nil {
        panic("Failed to allocate C.vde_context")
    }

    // 3. 将 Go 内存中的 eventHandler 指针传递给 C 库初始化函数
    // 只要 ctx 实例在Go中存活，其字段 eventHandler 就会一直存活，
    // 从而防止 Go GC 回收 C.vde_event_handler 结构体。
    C.VdeContext_Init(ctx.cContext, ctx.eventHandler)

    // 设置一个终结器来清理C库分配的内存
    runtime.SetFinalizer(ctx, func(v *VdeContext) {
        fmt.Printf("Go: Finalizer for VdeContext called, freeing C context at %p\n", unsafe.Pointer(v.cContext))
        C.VdeContext_Free(v.cContext)
    })

    return ctx
}

func main() {
    fmt.Println("--- Start of program ---")

    // 创建一个 VdeContext 实例
    vdeCtx := NewVdeContext()
    fmt.Printf("Go: VdeContext instance created, Go reference to eventHandler at %p\n", unsafe.Pointer(vdeCtx.eventHandler))

    // 模拟C代码使用事件处理器
    C.VdeContext_UseHandler(vdeCtx.cContext)

    // 模拟程序运行一段时间
    fmt.Println("Go: Program running, C code is actively using the handler...")

    // 假设 vdeCtx 变量不再需要，Go GC 最终会回收它。
    // 当 vdeCtx 被回收时，其 eventHandler 字段也会随之被回收。
    // 但在此之前，C代码可以安全地访问 eventHandler。
    // 为了演示GC，我们将 vdeCtx 设为 nil，并强制GC。
    vdeCtx = nil
    runtime.GC() // 强制执行垃圾回收，但不能保证立即回收

    fmt.Println("Go: VdeContext reference dropped, waiting for GC...")
    // 给予GC一些时间（在实际应用中不需要手动调用GC，这里仅为演示）
    for i := 0; i < 5; i++ {
        runtime.GC()
        // time.Sleep(100 * time.Millisecond)
    }

    fmt.Println("--- End of program ---")
}