Go 结构体成员的正确初始化姿势

import "sync"

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

func (m *SyncMap) Put(k, v string) {
    m.lock.Lock() // 尝试对nil的m.lock调用Lock()方法，导致nil指针恐慌
    defer m.lock.Unlock()

    m.hm[k] = v // 尝试对nil的m.hm进行写入操作，导致nil指针恐慌
}

func (m *SyncMap) Init() {
    m.hm = make(map[string]string)
    m.lock = new(sync.RWMutex) // 或者 &sync.RWMutex{}
}

// 使用时：
sm := new(SyncMap)
sm.Init() // 必须显式调用
sm.Put("Test", "Test")

import "sync"

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

// NewSyncMap 是 SyncMap 的构造函数
func NewSyncMap() *SyncMap {
    return &SyncMap{
        lock: new(sync.RWMutex),        // 初始化互斥锁指针
        hm:   make(map[string]string), // 初始化map
    }
}

// 使用构造函数创建实例：
func main() {
    sm := NewSyncMap() // 返回一个已完全初始化的SyncMap实例
    sm.Put("TestKey", "TestValue")
    // ... 其他操作
}

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

// SyncMapWithBackend 结构体，包含后台Goroutine和资源清理
type SyncMapWithBackend struct {
    lock    *sync.RWMutex
    hm      map[string]string
    stopSig chan struct{} // 用于停止后台Goroutine的信号
}

// backend 是 SyncMapWithBackend 的后台处理逻辑
func (m *SyncMapWithBackend) backend() {
    ticker := time.NewTicker(time.Second)
    defer ticker.Stop()
    for {
        select {
        case <-ticker.C:
            m.lock.RLock()
            fmt.Printf("后台Goroutine: 当前map大小为 %d\n", len(m.hm))
            m.lock.RUnlock()
        case <-m.stopSig:
            fmt.Println("后台Goroutine: 接收到停止信号，退出。")
            return
        }
    }
}

// stop 是 SyncMapWithBackend 的资源清理函数
func (m *SyncMapWithBackend) stop() {
    fmt.Println("Finalizer: 正在清理 SyncMapWithBackend 资源...")
    close(m.stopSig) // 发送停止信号给后台Goroutine
    // 可以在这里执行其他清理操作，例如关闭文件句柄、网络连接等
}

// NewSyncMapWithBackend 是 SyncMapWithBackend 的构造函数
func NewSyncMapWithBackend() *SyncMapWithBackend {
    sm := &SyncMapWithBackend{
        lock:    new(sync.RWMutex),
        hm:      make(map[string]string),
        stopSig: make(chan struct{}), // 初始化信号通道
    }

    // 注册资源清理函数：当sm不再被引用时，会尝试调用sm.stop()
    // 注意：Finalizer的执行时机不确定，不应依赖它进行关键资源释放
    runtime.SetFinalizer(sm, (*SyncMapWithBackend).stop)

    // 启动后台Goroutine
    go sm.backend()

    return sm
}

// Put 方法（与之前类似）
func (m *SyncMapWithBackend) Put(k, v string) {
    m.lock.Lock()
    defer m.lock.Unlock()
    m.hm[k] = v
}

// Get 方法
func (m *SyncMapWithBackend) Get(k string) (string, bool) {
    m.lock.RLock()
    defer m.lock.RUnlock()
    val, ok := m.hm[k]
    return val, ok
}

func main() {
    fmt.Println("创建 SyncMapWithBackend 实例...")
    sm := NewSyncMapWithBackend()
    sm.Put("key1", "value1")
    sm.Put("key2", "value2")

    time.Sleep(3 * time.Second) // 观察后台Goroutine的输出

    // 假设sm不再被引用，GC可能会触发finalizer
    // 为了演示，这里显式将sm置为nil，并强制GC (仅用于演示，实际不推荐)
    sm = nil
    runtime.GC()
    time.Sleep(1 * time.Second) // 等待finalizer执行

    fmt.Println("程序结束。")
}