Go语言结构体成员初始化：告别Nil指针恐慌

import "sync"

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

func (m *SyncMap) Put(k, v string) {
    m.lock.Lock() // 这里可能发生nil指针恐慌
    defer m.lock.Unlock()

    m.hm[k] = v // 这里可能发生nil指针恐慌
}

sm := new(SyncMap)
sm.Put("Test", "TestValue")

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", "TestValue")

import "sync"

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

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

func (m *SyncMap) Put(k, v string) {
    m.lock.Lock()
    defer m.lock.Unlock()

    m.hm[k] = v
}

// 使用构造函数创建实例
// sm := NewSyncMap()
// sm.Put("Test", "TestValue") // 不再发生panic

package main

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

type Resource struct {
    id     int
    data   map[string]string
    mu     *sync.RWMutex
    stopCh chan struct{} // 用于停止后台协程
}

// NewResource 是 Resource 的构造函数
func NewResource(id int) *Resource {
    res := &Resource{
        id:     id,
        data:   make(map[string]string),
        mu:     new(sync.RWMutex),
        stopCh: make(chan struct{}),
    }

    // 启动一个后台协程
    go res.backendWorker()

    // 设置一个终结器，当对象被垃圾回收时执行清理操作
    // 注意：终结器不能保证何时执行，仅用于非关键资源清理
    runtime.SetFinalizer(res, (*Resource).cleanup)

    fmt.Printf("Resource %d created and initialized.\n", id)
    return res
}

// backendWorker 是一个模拟后台工作的协程
func (r *Resource) backendWorker() {
    ticker := time.NewTicker(1 * time.Second)
    defer ticker.Stop()
    for {
        select {
        case <-ticker.C:
            r.mu.Lock()
            fmt.Printf("Resource %d: Doing background work, current data size: %d\n", r.id, len(r.data))
            r.mu.Unlock()
        case <-r.stopCh:
            fmt.Printf("Resource %d: Background worker stopped.\n", r.id)
            return
        }
    }
}

// cleanup 是资源清理函数，作为终结器使用
func (r *Resource) cleanup() {
    fmt.Printf("Resource %d: Finalizer called, performing cleanup...\n", r.id)
    // 关闭后台协程
    close(r.stopCh)
    // 释放其他资源，例如关闭文件句柄、网络连接等
    fmt.Printf("Resource %d: Cleanup complete.\n", r.id)
}

func (r *Resource) AddData(key, value string) {
    r.mu.Lock()
    defer r.mu.Unlock()
    r.data[key] = value
    fmt.Printf("Resource %d: Added data %s=%s\n", r.id, key, value)
}

func main() {
    // 创建一个Resource实例
    res1 := NewResource(1)
    res1.AddData("name", "Alice")
    res1.AddData("age", "30")

    // 让程序运行一段时间，观察后台协程
    time.Sleep(5 * time.Second)

    // 将res1设置为nil，使其可能被垃圾回收，从而触发finalizer
    // 注意：垃圾回收的时机不确定，finalizer不应作为资源管理的关键机制
    res1 = nil
    runtime.GC() // 手动触发GC，仅用于演示目的

    time.Sleep(2 * time.Second) // 等待GC和finalizer执行
    fmt.Println("Program finished.")
}