Golang 并发排序：使用 Goroutines 实现一亿数据快速处理

目标与环境准备

本案例旨在演示如何通过并发策略缩短长耗时任务的执行时间。我们需要在一个支持并发模型的 Go 环境中编写代码，核心目标是处理总量约为 1 亿个整数的排序任务。

主要依赖标准库：

• fmt：用于输出日志。
• sync：使用 WaitGroup 同步主流程与各并发协程的执行状态。
• sort：调用系统内置的高效排序算法对子数据进行排序。
• time & math/rand：用于统计耗时及生成测试随机数。

第1步：生成随机数流

为了模拟真实数据输入，首先需要构建随机数生成器。这里设计一个并发生产模式，由 100 个协程并行向 randNums 信道发送数据块。

func randProduce(randNums chan []int, wg *sync.WaitGroup) {
	// 启动100个协程并发生成数据
	for i := 0; i < 100; i++ {
		go rand1(randNums, wg)
	}
}

func rand1(randNums chan []int, wg *sync.WaitGroup) {
	r := rand.New(rand.NewSource(time.Now().Unix()))
	// 每个协程生成大小为 1,000,000 的切片
	int1000 := make([]int, 1000000)
	for i := 0; i < 1000000; i++ {
		int1000[i] = r.Intn(1000000)
	}
	randNums <- int1000 // 将生成的切片推入信道
	wg.Done()           // 通知当前协程完成
}

该步骤实现了数据的生产流水线化，randNums 缓冲信道为后续排序环节提供原料。

第2步：并发切分与子集排序

接收生成的数据流后，将其直接送入排序逻辑。利用 goroutine 并发地对各个独立的数据片段进行排序，以最大化 CPU 利用率。

func sort0(randNums chan []int, sortNums chan []int, wg *sync.WaitGroup) {
	// 依次取出100个数据块并派发给排序协程
	for i := 0; i < 100; i++ {
		go sort2(randNums, sortNums, wg)
	}
}

func sort2(randNums chan []int, sortNums chan []int, wg *sync.WaitGroup) {
	// 从生产信道取出一组数据
	int1000_Old := <-randNums
	sort.Ints(int1000_Old)       // 执行内部排序
	sortNums <- int1000_Old     // 将已排序切片推入排序结果信道
	wg.Done()
}

此阶段重点在于“解耦”，生产者与消费者之间通过信道交换切片引用，互不阻塞。

第3步：合并已排序的子数组

当所有子数组完成排序后，需要按顺序将它们重新合并为一个完整的有序大数组。由于子数组之间存在顺序依赖关系，这里的合并采用串行累加的方式进行。

func mergeAll(sortNums chan []int, wg *sync.WaitGroup) []int {
	defer wg.Done()
	// 获取第一个已排序的块作为起点
	temp2 := <-sortNums
	var temp1 []int
	
	// 依次取出剩余的99个块并合并
	for i := 1; i <= 99; i++ {
		// 扩容临时存储区
		temp1 = make([]int, 1000000*i+1000000)
		copy(temp1, temp2)
		// 执行两路归并操作
		temp1 = merge(temp1, 1000000*i+1000000, <-sortNums, 1000000)
		temp2 = make([]int, 1000000*i+1000000)
		copy(temp2, temp1)
	}
	return temp2
}

// merge 实现两个有序切片的归并逻辑
func merge(nums1 []int, m int, nums2 []int, n int) []int {
	temp := make([]int, m)
	copy(temp, nums1)
	t, j := 0, 0 // t指向原数组，j指向新加入的数组
	
	for i := 0; i < len(nums1); i++ {
		if t >= len(temp) {
			nums1[i] = nums2[j]
			j++
			continue
		}
		if j >= n {
			nums1[i] = temp[t]
			t++
			continue
		}
		if nums2[j] <= temp[t] {
			nums1[i] = nums2[j]
			j++
		} else {
			nums1[i] = temp[t]
			t++
		}
	}
	return nums1
}

第4步：主控流程组装

最后在 main 函数中初始化参数，建立调度中心，串联起整个数据流向。使用 sync.WaitGroup 确保三个关键节点（生产、排序、合并）全部完成后才计时结束。

func main() {
	fmt.Println("开始运行!")
	start := time.Now() // 记录开始时间
	wg := sync.WaitGroup{}
	
	// 信号量预分配：生产(1) + 排序(100) + 合并(1) ≈ 201个信号量
	wg.Add(201)
	
	randNums := make(chan []int, 100)  // 生产队列
	sortNUms := make(chan []int, 100)  // 排序结果队列
	
	// 启动三大流程模块
	go randProduce(randNums, &wg)
	go sort0(randNums, sortNUms, &wg)
	go mergeAll(sortNUms, &wg)
	
	// 阻塞等待所有协程退出
	wg.Wait()
	
	elapsed := time.Since(start)
	fmt.Println("该函数执行完成耗时：", elapsed)
}

性能比较与结论

虽然并发模型能充分利用多核处理器，但在实际运行中发现，对于中等规模以上的单一巨型任务，简单的多线程开销可能抵消部分优势。我们将上述方法与单线程产生数据后进行统一排序的逻辑进行了对比测试。尽管单线程方案缺少了并发排序的计算加速，但由于其省去了大量协程创建、调度以及内存分配的开销，两者的最终执行耗时差异并不显著。

这说明了在处理海量固定规模数据时，若没有极致的算力压榨需求，简单的串行逻辑配合优化的 IO 往往更具性价比；而在真正超大规模或 I/O 密集型场景中，并发排序的优势才会更加凸显。以上就是 Go 语言并发排序处理大规模数据的详细内容，更多关于 Go 语言多线程优化及并发控制的资料请关注本站其它相关文章！