当前位置：首页 > 文章列表 > Golang > Go教程 > Go并发不是并行？GOMAXPROCS详解

Go并发不是并行？GOMAXPROCS详解

2025-08-01 21:27:35 0浏览收藏

本篇文章给大家分享《Go语言并发不是并行？GOMAXPROCS解析》，覆盖了Golang的常见基础知识，其实一个语言的全部知识点一篇文章是不可能说完的，但希望通过这些问题，让读者对自己的掌握程度有一定的认识(B 数)，从而弥补自己的不足，更好的掌握它。

Go语言多核并行计算：GOMAXPROCS与并发并非并行

本文深入探讨了Go语言程序在多核环境下未能充分利用CPU资源的问题。核心在于理解Go的调度器默认行为以及GOMAXPROCS变量的作用。通过设置GOMAXPROCS，我们可以控制Go运行时可使用的操作系统线程数量，从而实现goroutine的并行执行。同时，文章强调了并发与并行的本质区别，并分析了不当设置GOMAXPROCS可能导致的性能下降，提供了优化建议和示例代码。

理解Go协程与并行执行

Go语言通过其轻量级的并发原语——goroutine，极大地简化了并发编程。开发者可以使用go关键字轻松启动数千甚至数万个goroutine。然而，一个常见的误解是，启动多个goroutine就意味着程序会自动在多个CPU核心上并行运行。实际上，Go的运行时调度器默认情况下可能只会使用一个操作系统线程来执行这些goroutine，即使系统拥有多个可用的CPU核心。这意味着，即使您的机器是多核处理器，Go程序也可能仅利用一个核心，无法实现真正的并行计算加速。

GOMAXPROCS：开启并行计算的关键

要让Go程序充分利用多核CPU资源，实现goroutine的并行执行，关键在于设置GOMAXPROCS变量。GOMAXPROCS控制Go运行时可以同时使用的最大操作系统线程数。默认情况下，Go 1.5版本之前，GOMAXPROCS的值默认为1，这意味着即使有多个CPU核心，Go程序也只会使用一个OS线程来调度goroutine。从Go 1.5版本开始，GOMAXPROCS的默认值被设置为CPU核心数，这在大多数情况下能更好地利用多核资源。然而，对于旧版本Go或者某些特定场景，手动设置GOMAXPROCS仍然是必要的。

设置GOMAXPROCS有两种主要方式：

通过环境变量设置： 在运行Go程序之前，可以通过设置shell环境变量来指定GOMAXPROCS的值。
```
export GOMAXPROCS=4 # 设置为4个核心
go run your_program.go
```
或者在执行时直接指定：
```
GOMAXPROCS=4 go run your_program.go
```
通过runtime包设置： 在程序代码内部，可以使用runtime包的GOMAXPROCS函数来动态设置。这通常是在程序的main函数开头完成。
```
import "runtime"

func main() {
    // 设置Go运行时最多使用4个OS线程
    runtime.GOMAXPROCS(4) 
    // 或者设置为CPU核心数
    // runtime.GOMAXPROCS(runtime.NumCPU()) 

    // ... 您的并发代码 ...
}
```
推荐使用runtime.NumCPU()来动态获取并设置，以适应不同机器的CPU配置。

并发与并行：一个重要的区别

理解GOMAXPROCS的作用，需要区分“并发”（Concurrency）和“并行”（Parallelism）这两个概念。

并发：指程序设计能够处理多个同时进行的任务。它关注的是任务的结构，即如何将任务分解成独立的、可以独立执行的部分。Go的goroutine和channel是实现并发的强大工具。即使只有一个CPU核心，程序也可以通过快速切换任务（时间片轮转）来模拟同时执行多个任务，给人一种“同时进行”的错觉。
并行：指多个任务真正地在同一时刻被不同的处理器（或处理器核心）同时执行。并行是并发的一种特殊情况，它需要多核CPU的支持，并且Go运行时需要通过GOMAXPROCS来调度goroutine到不同的OS线程上，进而映射到不同的CPU核心上。

简而言之，Go的go关键字创建的是并发，而要实现并行，则需要GOMAXPROCS来提供足够的OS线程，以便这些并发的任务能够真正在多个CPU核心上同时运行。

性能考量与最佳实践

虽然增加GOMAXPROCS可以利用多核CPU，但并非总是越大越好。在某些情况下，将其设置得过高反而可能导致程序变慢。这通常发生在以下场景：

频繁的上下文切换开销：当GOMAXPROCS设置得很高，导致Go调度器在多个OS线程之间频繁切换goroutine时，会产生显著的上下文切换开销。
通道通信开销：如果程序中包含大量goroutine，并且它们之间通过通道（channel）进行频繁的数据通信，那么当这些goroutine被调度到不同的OS线程上时，跨线程的数据传输会引入额外的同步和内存访问开销，这可能抵消并行带来的收益。

Go的调度器在不断优化中，但目前它可能无法完全智能地识别所有这类瓶颈。因此，建议根据应用程序的特性和负载，对GOMAXPROCS进行基准测试和调优。通常，将其设置为CPU核心数是一个合理的起点。对于I/O密集型任务，即使GOMAXPROCS设置为1，Go的非阻塞I/O模型也能很好地处理并发。对于计算密集型任务，提高GOMAXPROCS通常能带来性能提升。

示例代码优化

让我们以原问题中的代码为例，演示如何通过设置GOMAXPROCS来尝试实现并行计算。原代码尝试将一个大数的求和任务分解为多个goroutine并行执行，但如果GOMAXPROCS默认值为1，则无法利用多核。

package main

import (
    "fmt"
    "math/big"
    "runtime" // 引入runtime包
    "time"
)

var c chan *big.Int

// sum 函数计算指定范围内的和
func sum(start, stop, step int64) {
    bigStop := big.NewInt(stop)
    bigStep := big.NewInt(step)
    bigSum := big.NewInt(0)
    for i := big.NewInt(start); i.Cmp(bigStop) < 0; i.Add(i, bigStep) {
        bigSum.Add(bigSum, i)
    }
    c <- bigSum
}

func main() {
    // 关键步骤：设置GOMAXPROCS为CPU核心数
    // 这将允许Go运行时使用多个OS线程来调度goroutine
    runtime.GOMAXPROCS(runtime.NumCPU()) 
    fmt.Printf("GOMAXPROCS is set to: %d\n", runtime.GOMAXPROCS(-1)) // 打印当前GOMAXPROCS值

    s := big.NewInt(0)
    n := time.Now().UnixNano() // 使用time.Now().UnixNano()更现代

    step := int64(4) // 启动4个goroutine
    c = make(chan *big.Int, int(step))
    stop := int64(100000000) // 目标求和上限

    // 启动多个goroutine并行计算
    for j := int64(0); j < step; j++ {
        go sum(j, stop, step)
    }

    // 收集所有goroutine的计算结果
    for j := int64(0); j < step; j++ {
        s.Add(s, <-c)
    }

    n = time.Now().UnixNano() - n
    // 打印总和及执行时间（秒）
    fmt.Printf("Total sum: %s, Time taken: %.6f seconds\n", s.String(), float64(n)/1e9)
}

通过在main函数开头添加runtime.GOMAXPROCS(runtime.NumCPU())，我们明确告诉Go运行时可以利用所有可用的CPU核心。对于这种计算密集型的求和任务，这通常会显著提高执行效率，因为各个sum goroutine可以真正在不同的CPU核心上并行执行。

总结

Go语言的并发模型强大而优雅，但要实现真正的并行计算，利用多核CPU的全部潜力，开发者需要理解GOMAXPROCS的作用。通过合理设置GOMAXPROCS，并区分并发与并行，我们可以编写出既高效又充分利用硬件资源的Go程序。在实际应用中，始终建议对不同GOMAXPROCS设置下的程序性能进行测试，以找到最适合特定工作负载的配置。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于Golang的相关知识，也可关注golang学习网公众号。