深入理解Go语言中COM对象生命周期管理与GC交互

package main

import (
    "fmt"
    "syscall"
    "unsafe"
)

// IUnknownVtbl represents the vtable of IUnknown interface.
// It contains pointers to the QueryInterface, AddRef, and Release methods.
type IUnknownVtbl struct {
    QueryInterface uintptr
    AddRef         uintptr
    Release        uintptr
}

// IUnknown represents the base COM interface.
// It holds a pointer to its vtable.
type IUnknown struct {
    LpVtbl *IUnknownVtbl
}

// ComObject is a Go wrapper for a generic COM object pointer.
type ComObject struct {
    ptr *IUnknown // Pointer to the actual COM object
}

// NewComObject creates a new ComObject wrapper.
// It assumes the incoming comPtr already has an incremented reference count
// (e.g., returned from a COM function). If not, AddRef() might be needed here.
func NewComObject(comPtr unsafe.Pointer) *ComObject {
    return &ComObject{ptr: (*IUnknown)(comPtr)}
}

// AddRef increments the reference count of the COM object.
func (c *ComObject) AddRef() {
    if c.ptr != nil && c.ptr.LpVtbl != nil && c.ptr.LpVtbl.AddRef != 0 {
        // Syscall to call the AddRef method in the COM object's vtable.
        // The first argument is the address of the method.
        // The second argument is the number of arguments (1 for 'this' pointer).
        // The third argument is the 'this' pointer (the COM object itself).
        syscall.Syscall(c.ptr.LpVtbl.AddRef, 1, uintptr(unsafe.Pointer(c.ptr)), 0, 0)
    }
}

// Release decrements the reference count of the COM object.
// If the count reaches zero, the COM object is destroyed.
func (c *ComObject) Release() {
    if c.ptr != nil && c.ptr.LpVtbl != nil && c.ptr.LpVtbl.Release != 0 {
        // Syscall to call the Release method.
        syscall.Syscall(c.ptr.LpVtbl.Release, 1, uintptr(unsafe.Pointer(c.ptr)), 0, 0)
        c.ptr = nil // Clear the pointer to prevent double-free or use-after-free
    }
}

func main() {
    // --- 模拟COM对象创建和使用 ---
    // 在实际应用中，comPtr会通过CoCreateInstance, IWbemLocator::ConnectServer等COM API调用获得。
    // 这里为了演示，我们假设已经获取了一个有效的COM对象指针。
    // 注意：此处 comPtr 为 nil，仅用于演示 ComObject 结构和方法，实际运行时会panic。
    // 请替换为实际的COM对象指针。
    var comPtr unsafe.Pointer // 假设这是从COM API获得的有效COM对象指针

    if comPtr == nil {
        fmt.Println("Error: comPtr is nil. Please replace with an actual COM object pointer from a syscall.")
        // For demonstration, let's pretend we have a valid pointer
        // In a real scenario, this would involve complex setup like CoInitializeEx, CoCreateInstance etc.
        // For a minimal runnable example, we'll skip the actual COM object creation and focus on the wrapper.
        // If you run this as is, the Release/AddRef calls will panic because c.ptr is nil.
        // A robust implementation would involve actual COM calls.
        return
    }

    // 1. 使用 defer 管理 COM 对象的生命周期
    // 当从COM API获取到对象指针时，通常它已经有一个引用计数。
    // 我们用Go包装器来管理它。
    comObject := NewComObject(comPtr)
    defer comObject.Release() // 确保在 main 函数退出时释放 COM 对象

    fmt.Println("COM object wrapper created. Using defer for Release.")

    // 在这里执行对 COM 对象的实际操作，例如 WMI 查询、数据处理等
    fmt.Println("Performing operations with the COM object...")
    // 假设这里会调用COM对象的方法来获取数据
    // 例如：comObject.QueryInterface(...) 或其他自定义方法

    // 如果需要在某个特定时刻额外持有引用，可以调用 AddRef
    // comObject.AddRef()
    // fmt.Println("Reference count manually incremented.")
    // defer comObject.Release() // 如果调用了 AddRef，也需要对应的 Release

    fmt.Println("Operations with COM object finished.")
    // main 函数结束时，defer 会自动调用 comObject.Release()
}

package main

import (
    "fmt"
    "runtime"
    "syscall"
    "unsafe"
)

// ... IUnknown, IUnknownVtbl, ComObject 结构体同上 ...

// NewComObjectWithFinalizer creates a ComObject wrapper and sets a finalizer.
func NewComObjectWithFinalizer(comPtr unsafe.Pointer) *ComObject {
    obj := NewComObject(comPtr)
    // Set a finalizer to ensure Release() is called if the Go object is GC'd.
    runtime.SetFinalizer(obj, func(o *ComObject) {
        if o.ptr != nil {
            fmt.Println("Finalizer: Automatically releasing COM object...")
            o.Release() // Call Release within the finalizer
        }
    })
    return obj
}

func main() {
    // 模拟一个COM对象指针
    var comPtr unsafe.Pointer // 假设这是从COM API获得的有效指针

    if comPtr == nil {
        fmt.Println("Error: comPtr is nil. Please replace with an actual COM object pointer from a syscall.")
        return
    }

    // 使用 defer 显式管理 (推荐)
    obj1 := NewComObject(comPtr)
    defer obj1.Release()
    fmt.Println("obj1 created and explicitly managed with defer.")

    // 假设这里创建了一个新的COM对象，并使用Finalizer作为兜底
    // (在实际应用中，你可能不会同时使用defer和Finalizer来管理同一个COM对象)
    var comPtr2 unsafe.Pointer // 另一个假设的COM指针
    obj2 := NewComObjectWithFinalizer(comPtr2)
    fmt.Println("obj2 created with finalizer as fallback.")

    // 模拟使用 obj1 和 obj2
    fmt.Println("Using COM objects...")
    // ...

    // 为了演示Finalizer，我们可以将 obj2 设置为 nil，并强制GC运行。
    // 在实际程序中，不建议手动触发GC。
    obj2 = nil // Go对象不再被引用，GC有机会回收它
    runtime.GC()
    fmt.Println("GC triggered. Finalizer for obj2 might run soon (but not guaranteed immediately).")

    // 确保主goroutine有足够时间让GC运行和Finalizer执行
    // time.Sleep(100 * time.Millisecond) // Give some time for finalizer to run
    fmt.Println("Main function finished.")
}