Go语言中实现高效字符串去重（Interning）策略

package main

import (
    "fmt"
    "unsafe" // 仅在需要使用unsafe解决方案时导入
)

// Interner 定义了一个用于字符串去重的类型
type Interner map[string]string

// NewInterner 创建并返回一个新的Interner实例
func NewInterner() Interner {
    return Interner(make(map[string]string))
}

// Intern 方法接收一个字符串s，并返回其去重后的版本。
// 如果s已存在于Interner中，则返回已有的实例；否则，将s添加进去并返回s本身。
func (m Interner) Intern(s string) string {
    if ret, ok := m[s]; ok {
        return ret
    }

    // 在这里插入处理内存钉死问题的代码（见下一节）
    // 例如：s = copyString(s) 或 s = unsafeCopyString(s)

    m[s] = s
    return s
}

func main() {
    interner := NewInterner()

    str1 := "hello"
    str2 := "world"
    str3 := "hello"
    str4 := "go"
    str5 := "world"

    // 使用Intern方法进行字符串去重
    internedStr1 := interner.Intern(str1)
    internedStr2 := interner.Intern(str2)
    internedStr3 := interner.Intern(str3) // 应该与internedStr1是同一个实例
    internedStr4 := interner.Intern(str4)
    internedStr5 := interner.Intern(str5) // 应该与internedStr2是同一个实例

    fmt.Printf("原始字符串：%p, %s\n", &str1, str1)
    fmt.Printf("去重后字符串1：%p, %s\n", &internedStr1, internedStr1)
    fmt.Printf("去重后字符串3：%p, %s\n", &internedStr3, internedStr3)
    fmt.Printf("去重后字符串2：%p, %s\n", &internedStr2, internedStr2)
    fmt.Printf("去重后字符串5：%p, %s\n", &internedStr5, internedStr5)

    // 验证去重效果：internedStr1 和 internedStr3 应该指向同一个底层数据
    fmt.Printf("internedStr1 == internedStr3: %t\n", internedStr1 == internedStr3)
    fmt.Printf("底层数据地址比较 (internedStr1 vs internedStr3): %p == %p\n",
        unsafe.StringData(internedStr1), unsafe.StringData(internedStr3))

    fmt.Printf("internedStr2 == internedStr5: %t\n", internedStr2 == internedStr5)
    fmt.Printf("底层数据地址比较 (internedStr2 vs internedStr5): %p == %p\n",
        unsafe.StringData(internedStr2), unsafe.StringData(internedStr5))
}

// copyString 通过双重拷贝确保字符串拥有独立的底层数据
func copyString(s string) string {
    b := []byte(s) // 第一次拷贝：s的内容被复制到一个新的[]byte中
    s = string(b)  // 第二次拷贝：从新的[]byte创建一个新的string，其底层数据独立
    return s
}

// 修改Intern方法以使用双重拷贝
func (m Interner) Intern(s string) string {
    if ret, ok := m[s]; ok {
        return ret
    }

    s = copyString(s) // 在存储前进行拷贝
    m[s] = s
    return s
}

// unsafeCopyString 使用unsafe包将[]byte转换为string，避免拷贝
// 警告：使用unsafe包存在风险，可能导致未定义行为，且依赖于Go编译器的内部实现。
// 在Go 1.20+版本中，推荐使用strings.Clone()来安全地实现字符串深拷贝。
func unsafeCopyString(s string) string {
    b := []byte(s) // 第一次拷贝：s的内容被复制到一个新的[]byte中
    // 警告：以下操作依赖于Go字符串和切片的内部结构，未来版本可能失效
    s = *(*string)(unsafe.Pointer(&b)) // 将[]byte的底层数据指针直接转换为string
    return s
}

// 修改Intern方法以使用unsafe拷贝 (仅作示例，不推荐在生产环境随意使用)
func (m Interner) Intern(s string) string {
    if ret, ok := m[s]; ok {
        return ret
    }

    // 仅作示例，生产环境请慎重考虑
    // s = unsafeCopyString(s) // 在存储前进行unsafe拷贝

    // 推荐使用Go 1.18+内置的strings.Clone()，它能安全地深拷贝字符串
    // s = strings.Clone(s) // Go 1.18+ 安全的深拷贝

    m[s] = s
    return s
}