答案是通过优化算法和减少计算开销提升性能。示例中使用埃拉托斯特尼筛法替代暴力判断，显著降低时间复杂度，结合Go的性能分析工具pprof定位瓶颈，最终提高CPU密集型任务执行效率。
在Go语言开发中，CPU密集型任务的性能调优是提升程序效率的关键环节。这类函数通常涉及大量计算，比如数学运算、图像处理或数据编码。如果未经过优化，很容易成为程序瓶颈。下面通过一个实际示例，展示如何对CPU密集型函数进行性能分析和调优。
问题背景：计算素数个数
我们以“统计某个范围内素数的个数”为例，这是一个典型的CPU密集型操作：
func countPrimes(n int) int {
count := 0
for i := 2; i < n; i++ {
if isPrime(i) {
count++
}
}
return count
}
func isPrime(num int) bool {
if num < 2 {
return false
}
for i := 2; i*i <= num; i++ {
if num%i == 0 {
return false
}
}
return true
}
当 n = 100000 时，该函数执行时间较长。我们可以先进行基准测试来量化性能。
使用基准测试定位性能
编写基准测试，观察原始性能表现：
立即学习“go语言免费学习笔记（深入）”；
func BenchmarkCountPrimes(b *testing.B) {
for i := 0; i < b.N; i++ {
countPrimes(100000)
}
}运行命令：
go test -bench=.
输出可能类似：
BenchmarkCountPrimes-8 10 150000000 ns/op
每次调用耗时约150ms，性能较差。接下来进行优化。
优化策略一：使用埃拉托斯特尼筛法
原算法对每个数都做质数判断，复杂度为 O(n√n)。改用筛法可将复杂度降至 O(n log log n)。
func countPrimesOptimized(n int) int {
if n <= 2 {
return 0
}
isComposite := make([]bool, n)
count := 0
for i := 2; i < n; i++ {
if !isComposite[i] {
count++
for j := i * i; j < n; j += i {
isComposite[j] = true
}
}
}
return count
}筛法只标记合数，避免重复判断。重新运行基准测试：
BenchmarkCountPrimesOptimized-8 100 10000000 ns/op
性能提升约15倍，效果显著。
优化策略二：启用并发并行计算
现代CPU多核，可利用Go的goroutine进一步加速。将范围分段，并发处理：
func countPrimesParallel(n int) int {
if n <= 2 {
return 0
}
numWorkers := runtime.NumCPU()
chunkSize := (n + numWorkers - 1) / numWorkers
var wg sync.WaitGroup
var mu sync.Mutex
totalCount := 0
for i := 0; i < numWorkers; i++ {
start := i*chunkSize + 2
end := min((i+1)*chunkSize, n)
if start >= n {
continue
}
wg.Add(1)
go func(s, e int) {
defer wg.Done()
localCount := 0
isComposite := make([]bool, e-s+1) // 局部筛法空间
for i := 2; i*i < e; i++ {
for j := max(i*i, (s+i-1)/i*i); j < e; j += i {
if j >= s {
isComposite[j-s] = true
}
}
}
for i := s; i < e; i++ {
if !isComposite[i-s] {
localCount++
}
}
mu.Lock()
totalCount += localCount
mu.Unlock()
}(start, end)
}
wg.Wait()
return totalCount}
注意：此处使用了局部筛法（分段筛），避免共享大数组带来的锁竞争。
再次测试并发版本：
BenchmarkCountPrimesParallel-8 50 25000000 ns/op
虽然比单线程筛法慢，但说明并发并不总是更快。原因包括：
- 任务划分开销大
- 内存局部性下降
- 锁竞争（即使减少）仍存在
对于这种整体性强的算法，并发收益有限。更合适的场景是完全独立的计算任务。
进一步优化建议
- 减少内存分配：复用切片，使用 sync.Pool 缓存中间结构
- 位压缩：用 bitset 替代 bool slice，节省内存和提高缓存命中率
- 编译器优化：开启编译优化（Go默认已开启）
- 性能剖析：使用 pprof 分析热点函数
例如，使用位压缩后内存占用减少8倍，可能进一步提升速度。
基本上就这些。关键是先测量，再优化，避免过早引入并发等复杂机制。算法改进往往比并发带来更大收益。
