Go CGO与C语言结构体函数指针：避免垃圾回收引发的空指针问题

package main

/*
#include <stdlib.h> // For C.free in a real scenario if C-allocated
// 假设这是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库中初始化并存储处理器指针的函数
extern void init_vde_context(vde_event_handler* handler);

// 假设这些是C库中的实际函数，或者通过CGO导出的Go函数
void c_event_add_func() {}
void c_event_del_func() {}
void c_timeout_add_func() {}
void c_timeout_del_func() {}
*/
import "C"
import "unsafe"

// 原始的Go函数，尝试创建并返回C结构体的指针
// func createNewEventHandler() *C.vde_event_handler {
//     var libevent_eh C.vde_event_handler // 在Go栈上或Go堆上分配
//     // C.event_base_new() // 假设这里有其他C库初始化
//     return &libevent_eh // 返回其地址
// }

// 模拟C库的初始化函数（在实际C代码中实现）
func main() {
    // 假设这是C库的初始化函数，它将存储并稍后使用handlerPtr
    // C.init_vde_context(createNewEventHandler())
    // ...
}

package main

/*
#include <stdlib.h> // For C.free if C-allocated, though not strictly needed for this Go-allocated struct example

// 假设这是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库中的实际函数，或者通过CGO导出的Go函数
void c_event_add_func() { /* ... */ }
void c_event_del_func() { /* ... */ }
void c_timeout_add_func() { /* ... */ }
void c_timeout_del_func() { /* ... */ }

// 假设这是C库中初始化并存储处理器指针的函数
// 在实际C代码中，这个函数会存储传入的handler指针
extern void init_vde_context(vde_event_handler* handler);
*/
import "C"
import "fmt"
import "runtime"
import "time"

// VdeContext 是Go侧表示C库上下文的结构体
type VdeContext struct {
    // eventHandler 是一个关键字段，它持有对Go分配的C.vde_event_handler结构体的引用。
    // 只要VdeContext实例存在，这个eventHandler就不会被Go垃圾回收器回收。
    eventHandler *C.vde_event_handler
    // 其他C库相关的上下文信息
    // ...
}

// NewVdeContext 创建一个新的VdeContext实例并初始化C库事件处理器
func NewVdeContext() *VdeContext {
    ctx := &VdeContext{}

    // 1. 在Go堆上分配C.vde_event_handler结构体。
    // 使用&C.vde_event_handler{}确保它是一个指针，并且Go会管理其生命周期。
    eh := &C.vde_event_handler{}

    // 2. 初始化结构体中的函数指针。
    // 这些指针应该指向C函数，或者通过CGO导出的Go函数。
    eh.event_add = C.c_event_add_func
    eh.event_del = C.c_event_del_func
    eh.timeout_add = C.c_timeout_add_func
    eh.timeout_del = C.c_timeout_del_func

    // 3. 将Go分配的结构体指针存储在VdeContext实例中。
    // 这是防止Go垃圾回收器过早回收的关键步骤。
    ctx.eventHandler = eh

    // 4. 将该处理器的指针传递给C库进行初始化。
    // C库现在可以安全地存储和使用这个指针，因为它在Go侧有明确的引用。
    C.init_vde_context(ctx.eventHandler)

    fmt.Println("Go: VdeContext initialized with event handler.")
    return ctx
}

// CloseVdeContext 负责清理VdeContext资源，如果C库需要，可以通知C库释放资源
func (ctx *VdeContext) CloseVdeContext() {
    // 如果C库有对应的清理函数，可以在这里调用
    // C.cleanup_vde_context(ctx.eventHandler)

    // 显式地将eventHandler置为nil，以便Go GC可以回收它
    // (如果C库不再需要它的话)
    ctx.eventHandler = nil
    fmt.Println("Go: VdeContext closed and event handler reference released.")
}

// 模拟C库的init_vde_context函数，它会存储handler指针并在一段时间后使用
func main() {
    fmt.Println("Starting CGO handler lifecycle demo...")

    // 创建VdeContext实例，它会负责维护eventHandler的生命周期
    vdeCtx := NewVdeContext()

    // 模拟程序运行一段时间，C库在此期间可能会使用eventHandler
    fmt.Println("Go: Application running, C library might be using the handler...")
    time.Sleep(2 * time.Second) // 模拟C库长时间持有并使用指针

    // 强制进行一次GC，以证明只要有Go引用，内存就不会被回收
    fmt.Println("Go: Forcing GC cycle (handler should still be valid)...")
    runtime.GC()
    time.Sleep(500 * time.Millisecond) // 等待GC完成

    // 此时eventHandler仍然有效，因为vdeCtx持有它的引用

    // 当VdeContext不再需要时，进行清理
    vdeCtx.CloseVdeContext()

    // 模拟程序继续运行，现在eventHandler的Go引用已释放，GC可以回收它
    fmt.Println("Go: Handler reference released. Forcing GC again (now it can be collected)...")
    runtime.GC()
    time.Sleep(500 * time.Millisecond) // 等待GC完成

    fmt.Println("CGO handler lifecycle demo finished.")
}

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

// 匹配Go代码中的vde_event_handler结构体定义
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代码中存储Go传入的handler指针
static vde_event_handler* global_c_handler = NULL;

// C库初始化函数，接收Go传入的handler指针并存储
void init_vde_context(vde_event_handler* handler) {
    global_c_handler = handler;
    printf("C: Received handler at %p\n", (void*)handler);
    if (global_c_handler && global_c_handler->event_add) {
        printf("C: Handler->event_add is valid at %p\n", (void*)global_c_handler->event_add);
        // 实际应用中会调用这些函数
        // global_c_handler->event_add();
    } else {
        printf("C: Handler or its functions are NULL!\n");
    }
}

// C库中实际的函数实现
void c_event_add_func() { printf("C: c_event_add_func called.\n"); }
void c_event_del_func() { printf("C: c_event_del_func called.\n"); }
void c_timeout_add_func() { printf("C: c_timeout_add_func called.\n"); }
void c_timeout_del_func() { printf("C: c_timeout_del_func called.\n"); }

// 编译Go代码时，需要将这个C文件一起编译
// go build -ldflags "-r $ORIGIN" -o myapp .