Go语言结构体成员的正确初始化实践

import "sync"

type SyncMap struct {
    lock *sync.RWMutex // 指针类型，默认零值为 nil
    hm   map[string]string // 映射类型，默认零值为 nil
}

func (m *SyncMap) Put(k, v string) {
    // 如果 m.lock 或 m.hm 是 nil，这里会发生 panic
    m.lock.Lock()
    defer m.lock.Unlock()
    m.hm[k] = v // 对 nil map 进行写入操作会导致 panic
}

import "sync"

type SyncMap struct {
    lock *sync.RWMutex
    hm   map[string]string
}

// NewSyncMap 是 SyncMap 的构造函数，负责初始化其内部成员
func NewSyncMap() *SyncMap {
    return &SyncMap{
        lock: new(sync.RWMutex),        // 使用 new() 初始化 sync.RWMutex 指针
        hm:   make(map[string]string),  // 使用 make() 初始化 map
    }
}

func (m *SyncMap) Put(k, v string) {
    m.lock.Lock()
    defer m.lock.Unlock()
    m.hm[k] = v
}

// 使用示例：
func main() {
    sm := NewSyncMap() // 通过构造函数获取一个完全初始化的 SyncMap 实例
    sm.Put("key1", "value1")
    // ... 其他操作
}

import (
    "fmt"
    "runtime"
    "sync"
    "time"
)

type ComplexResource struct {
    mu       *sync.Mutex
    data     map[string]interface{}
    isClosed bool
    stopChan chan struct{} // 用于停止后台协程
}

// backend 是一个模拟的后台处理协程
func (cr *ComplexResource) backend() {
    for {
        select {
        case <-cr.stopChan:
            fmt.Println("Backend goroutine stopped.")
            return
        case <-time.After(time.Second):
            cr.mu.Lock()
            fmt.Printf("Backend processing data: %v\n", cr.data)
            cr.mu.Unlock()
        }
    }
}

// stop 是一个模拟的清理函数，可作为终结器
func (cr *ComplexResource) stop() {
    if !cr.isClosed {
        fmt.Println("Resource is being finalized. Closing...")
        close(cr.stopChan)
        cr.isClosed = true
    }
}

// NewComplexResource 是一个更复杂的构造函数
func NewComplexResource() *ComplexResource {
    cr := &ComplexResource{
        mu:       new(sync.Mutex),
        data:     make(map[string]interface{}),
        stopChan: make(chan struct{}), // 初始化通道
        isClosed: false,
    }

    // 注册终结器 (注意: 终结器不保证何时执行，且不推荐作为主要的资源管理方式)
    runtime.SetFinalizer(cr, (*ComplexResource).stop)

    // 启动后台协程
    go cr.backend()

    return cr
}

// Close 方法用于显式关闭资源，推荐使用
func (cr *ComplexResource) Close() {
    cr.mu.Lock()
    defer cr.mu.Unlock()
    if !cr.isClosed {
        fmt.Println("Explicitly closing resource.")
        close(cr.stopChan)
        cr.isClosed = true
    }
}

// 使用示例：
func main() {
    resource := NewComplexResource()
    // 模拟使用资源
    resource.mu.Lock()
    resource.data["key"] = "value"
    resource.mu.Unlock()

    time.Sleep(3 * time.Second) // 观察后台协程输出

    // 显式关闭资源 (推荐做法)
    resource.Close()

    // 等待协程停止
    time.Sleep(1 * time.Second)

    // resource = nil // 如果不调用 Close，GC 可能会在未来某个时刻调用 finalizer
    // runtime.GC() // 强制 GC 只是为了演示 finalizer，实际不推荐
    // time.Sleep(1 * time.Second)
}