Go语言中字符串键Map性能优化：深入理解与Interning实践

func (nb *Classifier) calcProbs(data string) *BoundedPriorityQueue {
    // ...
    terms := strings.Split(data, " ")
    for class, prob := range nb.classProb { // 第一次Map遍历，访问nb.classProb (map[string]float64)
        condProb := prob
        clsProbs := nb.model[class] // 第二次Map访问，使用字符串键'class'访问nb.model (map[string]map[string]float64)
        for _, term := range terms {
            termProb := clsProbs[term] // 第三次Map访问，使用字符串键'term'访问内层Map (map[string]float64)
            // ...
        }
        // ...
    }
    return probs
}

go get github.com/BurntSushi/intern

package main

import (
    "container/heap"
    "fmt"
    "log"
    "math"
    "strings"

    "github.com/BurntSushi/intern"
)

// Item 是 BoundedPriorityQueue 中的元素
type Item struct {
    value    interface{} // 存储驻留字符串或其ID
    priority float64     // 优先级
    index    int         // 堆中元素的索引
}

// BoundedPriorityQueue 实现 heap.Interface 接口
type BoundedPriorityQueue []*Item

func (pq BoundedPriorityQueue) Len() int { return len(pq) }

func (pq BoundedPriorityQueue) Less(i, j int) bool {
    return pq[i].priority < pq[j].priority
}

func (pq BoundedPriorityQueue) Swap(i, j int) {
    pq[i], pq[j] = pq[j], pq[i]
    pq[i].index = i
    pq[j].index = j
}

func (pq *BoundedPriorityQueue) Push(x interface{}) {
    n := len(*pq)
    item := x.(*Item)
    item.index = n
    *pq = append(*pq, item)
}

func (pq *BoundedPriorityQueue) Pop() interface{} {
    old := *pq
    n := len(old)
    item := old[n-1]
    old[n-1] = nil // 避免内存泄漏
    item.index = -1 // For safety
    *pq = old[0 : n-1]
    return item
}

// Classifier 结构体，现在使用 interned 字符串作为 Map 键
type Classifier struct {
    interner  *intern.Interner
    classProb map[interface{}]float64               // 键为驻留字符串
    model     map[interface{}]map[interface{}]float64 // 外层和内层键都为驻留字符串
    // 其他字段...
}

// NewClassifier 构造函数，初始化并驻留所有已知字符串
func NewClassifier(allClasses []string, allTerms []string) *Classifier {
    it := intern.NewInterner()
    nb := &Classifier{
        interner:  it,
        classProb: make(map[interface{}]float64),
        model:     make(map[interface{}]map[interface{}]float64),
    }

    // 预先驻留所有类别和术语字符串
    // 在实际应用中，这些字符串可能来自数据集加载阶段
    internedClassMap := make(map[string]interface{})
    for _, classStr := range allClasses {
        internedClassMap[classStr] = it.Intern(classStr)
    }

    internedTermMap := make(map[string]interface{})
    for _, termStr := range allTerms {
        internedTermMap[termStr] = it.Intern(termStr)
    }

    // 填充 classProb (示例数据)
    for classStr, internedClass := range internedClassMap {
        nb.classProb[internedClass] = float64(len(classStr)) / 100.0 // 示例概率
    }

    // 填充 model (示例数据)
    for classStr, internedClass := range internedClassMap {
        nb.model[internedClass] = make(map[interface{}]float64)
        for termStr, internedTerm := range internedTermMap {
            // 示例条件概率
            nb.model[internedClass][internedTerm] = float64(len(classStr)+len(termStr)) / 200.0
        }
    }

    return nb
}

// calcProbs 修改后使用驻留字符串进行Map访问
func (nb *Classifier) calcProbs(data string) *BoundedPriorityQueue {
    probs := &BoundedPriorityQueue{}
    heap.Init(probs)

    terms := strings.Split(data, " ")

    // 对输入数据中的术语进行驻留
    internedInputTerms := make([]interface{}, len(terms))
    for i, term := range terms {
        internedInputTerms[i] = nb.interner.Intern(term)
    }

    for classInterned, prob := range nb.classProb { // 遍历驻留键
        condProb := prob
        clsProbs := nb.model[classInterned] // 使用驻留键访问外层Map
        for _, termInterned := range internedInputTerms { // 遍历驻留输入术语
            termProb := clsProbs[termInterned] // 使用驻留键访问内层Map
            if termProb != 0 {
                condProb += math.Log10(termProb)
            } else {
                condProb += -6 // math.Log10(0.000001)
            }
        }

        // 注意：如果 Item.value 最终需要原始字符串，可能需要额外的反向查找或在Interner中存储原始字符串
        // 这里假设 Item.value 可以是 interface{} 类型
        entry := &Item{
            value:    classInterned, // 存储驻留值
            priority: condProb,
        }
        heap.Push(probs, entry)
    }
    return probs
}

func main() {
    // 模拟大量类别和术语
    numClasses := 1000
    numTerms := 30000
    allClasses := make([]string, numClasses)
    for i := 0; i < numClasses; i++ {
        allClasses[i] = fmt.Sprintf("class_%d", i)
    }
    allTerms := make([]string, numTerms)
    for i := 0; i < numTerms; i++ {
        allTerms[i] = fmt.Sprintf("term_%d", i)
    }

    classifier := NewClassifier(allClasses, allTerms)

    // 模拟分类数据
    testData := "term_10 term_25000 term_500 term_10000 term_15000"

    fmt.Println("开始分类...")
    // 运行多次以模拟实际负载
    for i := 0; i < 100; i++ { // 减少循环次数，避免示例运行过长
        _ = classifier.calcProbs(testData)
    }
    fmt.Println("分类完成。")

    // 实际应用中，可以通过 pprof 再次分析性能，观察 mapaccess1_faststr 的变化
    // log.Println("请使用 pprof 再次分析性能，观察 mapaccess1_faststr 的变化。")
}