Go语言文本去重：如何将百万级文本去重时间从17秒优化到更短？

在处理百万级文本去重时，性能优化是一个关键问题。以下是一些优化策略，可以帮助你将去重时间从17秒优化到更短：

1. 使用更高效的数据结构

Go语言中的map数据结构非常适合去重操作，因为它的查找和插入操作的平均时间复杂度是O(1)。确保你使用的是map[string]struct{}，因为struct{}不占用内存空间。

seen := make(map[string]struct{})
for _, text := range texts {
    if _, exists := seen[text]; !exists {
        seen[text] = struct{}{}
        // 处理去重后的文本
    }
}

2. 并行处理

如果文本数据可以分块处理，可以考虑使用Go的并发机制（如goroutine和channel）来并行处理数据。这样可以充分利用多核CPU的优势。

var wg sync.WaitGroup
seen := make(map[string]struct{})
mu := &sync.Mutex{}

chunkSize := len(texts) / numWorkers
for i := 0; i < numWorkers; i++ {
    wg.Add(1)
    go func(start, end int) {
        defer wg.Done()
        localSeen := make(map[string]struct{})
        for j := start; j < end; j++ {
            text := texts[j]
            if _, exists := localSeen[text]; !exists {
                localSeen[text] = struct{}{}
                mu.Lock()
                seen[text] = struct{}{}
                mu.Unlock()
            }
        }
    }(i*chunkSize, (i+1)*chunkSize)
}
wg.Wait()

3. 减少内存分配

频繁的内存分配和垃圾回收会影响性能。可以通过预分配内存或使用对象池来减少内存分配。

seen := make(map[string]struct{}, len(texts))
for _, text := range texts {
    if _, exists := seen[text]; !exists {
        seen[text] = struct{}{}
        // 处理去重后的文本
    }
}

4. 使用更快的哈希函数

Go语言的map内部使用哈希表，默认的哈希函数可能不是最快的。如果文本数据量非常大，可以考虑使用更快的哈希函数，如xxhash或fnv。

import "github.com/cespare/xxhash"

func hashText(text string) uint64 {
    return xxhash.Sum64String(text)
}

seen := make(map[uint64]struct{})
for _, text := range texts {
    h := hashText(text)
    if _, exists := seen[h]; !exists {
        seen[h] = struct{}{}
        // 处理去重后的文本
    }
}

5. 分批处理

如果内存有限，可以将文本数据分批处理，每批处理一定数量的文本，然后将去重后的结果合并。

batchSize := 100000
seen := make(map[string]struct{})
for i := 0; i < len(texts); i += batchSize {
    end := i + batchSize
    if end > len(texts) {
        end = len(texts)
    }
    batch := texts[i:end]
    for _, text := range batch {
        if _, exists := seen[text]; !exists {
            seen[text] = struct{}{}
            // 处理去重后的文本
        }
    }
}

6. 使用外部存储

如果内存不足以容纳所有文本数据，可以考虑使用外部存储（如Redis或数据库）来存储去重后的结果。这样可以减少内存压力，但可能会增加I/O开销。

import "github.com/go-redis/redis/v8"

rdb := redis.NewClient(&redis.Options{
    Addr: "localhost:6379",
})

for _, text := range texts {
    if rdb.SAdd(ctx, "unique_texts", text).Val() == 1 {
        // 处理去重后的文本
    }
}

7. 使用布隆过滤器

布隆过滤器是一种空间效率极高的概率型数据结构，用于判断一个元素是否在集合中。它可以快速判断一个文本是否可能已经存在，从而减少不必要的map查找操作。

import "github.com/bits-and-blooms/bloom/v3"

filter := bloom.NewWithEstimates(1000000, 0.01)
for _, text := range texts {
    if !filter.TestString(text) {
        filter.AddString(text)
        // 处理去重后的文本
    }
}

8. 优化I/O操作

如果文本数据是从文件或网络中读取的，确保I/O操作是高效的。可以使用缓冲读取或异步I/O来减少等待时间。

file, err := os.Open("texts.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

scanner := bufio.NewScanner(file)
seen := make(map[string]struct{})
for scanner.Scan() {
    text := scanner.Text()
    if _, exists := seen[text]; !exists {
        seen[text] = struct{}{}
        // 处理去重后的文本
    }
}

总结

通过使用更高效的数据结构、并行处理、减少内存分配、使用更快的哈希函数、分批处理、外部存储、布隆过滤器以及优化I/O操作，你可以显著减少百万级文本去重的时间。根据具体的应用场景和数据特点，选择合适的优化策略组合，可以进一步优化性能。