1亿条数据动态增长，取top10，怎么用golang实现

在Go语言中，可以使用heap（堆）数据结构来实现top k问题。下面是一个参考实现：

package main

import (
	"container/heap"
	"fmt"
)

type Item struct {
	value    string
	priority int
	index    int
}

type PriorityQueue []*Item

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

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

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

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

func (pq *PriorityQueue) Pop() interface{} {
	old := *pq
	n := len(old)
	item := old[n-1]
	item.index = -1
	*pq = old[0 : n-1]
	return item
}

func main() {
	// 初始化一个容量为10的小根堆
	pq := make(PriorityQueue, 0)
	heap.Init(&pq)

	// 模拟从数据源不断获取数据，并加入小根堆
	for i := 1; i <= 100000000; i++ {
		value := fmt.Sprintf("data-%d", i)
		priority := i
		item := &Item{
			value:    value,
			priority: priority,
		}
		if pq.Len() < 10 {
			heap.Push(&pq, item)
		} else if item.priority > pq[0].priority {
			heap.Pop(&pq)
			heap.Push(&pq, item)
		}
	}

	// 输出堆中的前10个元素
	for pq.Len() > 0 {
		item := heap.Pop(&pq).(*Item)
		fmt.Printf("%s: %d\n", item.value, item.priority)
	}
}

该实现中，使用一个容量为10的小根堆，从数据源中不断获取数据，并将数据加入小根堆中。如果堆的大小小于10，直接加入堆中；否则，比较当前数据的优先级（即数据的大小），如果比堆顶元素大，则弹出堆顶元素，将当前数据加入堆中。最后输出堆中的前10个元素，即为top 10。

需要注意的是，这种方法只适用于数据量比较小的情况，如果数据量非常大，可能会导致内存溢出。在实际使用中，可以考虑使用分布式计算框架，例如Hadoop或Spark，来处理大规模数据集。