深入理解Go并发模式：通过GOMAXPROCS实现多路复用与并行执行

本文深入探讨go语言中的并发多路复用模式，并着重解释了`runtime.gomaxprocs`在实现真正并行执行中的关键作用。通过分析一个常见的并发示例，我们将理解为何在默认配置下并发程序可能呈现顺序执行，以及如何通过配置`gomaxprocs`来充分利用多核cpu资源，从而实现预期的非确定性并发行为。

Go并发编程基础：Goroutine与Channel

Go语言以其内置的并发原语——goroutine和channel——极大地简化了并发编程。Goroutine是Go运行时管理的轻量级线程，它们在操作系统线程上进行多路复用。Channel则提供了goroutine之间安全通信的机制。

在构建并发应用程序时，一种常见的模式是“多路复用”（Multiplexing），即从多个并发源收集数据到一个单一的通道中。这允许消费者以非阻塞的方式处理来自不同生产者的信息，无论哪个生产者首先准备好数据。

考虑以下一个模拟两个“无聊”的goroutine并发生成消息，并由一个fanIn函数将它们的消息汇聚到单一通道的示例：

package main

import (
    "fmt"
    "math/rand"
    "runtime"
    "time"
)

// fanIn 函数实现多路复用，从两个输入通道收集消息到一个输出通道
func fanIn(in1, in2 <-chan string) <-chan string {
    c := make(chan string)
    go func() {
        for {
            c <- <-in1 // 从in1读取并发送到c
        }
    }()
    go func() {
        for {
            c <- <-in2 // 从in2读取并发送到c
        }
    }()
    return c
}

// boring 函数模拟一个持续生成消息的goroutine
func boring(msg string) <-chan string {
    c := make(chan string)
    go func() {
        for i := 0; ; i++ {
            c <- fmt.Sprintf("%s %d", msg, i)
            // 模拟随机延迟，以体现并发的非确定性
            time.Sleep(time.Duration(rand.Intn(1e3)) * time.Millisecond)
        }
    }()
    return c
}

func main() {
    // 初始化随机数种子
    rand.Seed(time.Now().UnixNano())

    c := fanIn(boring("Joe"), boring("Ann")) // 启动两个boring goroutine并通过fanIn汇聚
    for i := 0; i < 10; i++ {
        fmt.Println(<-c) // 从汇聚通道接收消息
    }
    fmt.Println("You're both boring: I'm leaving")
}

期望的结果是Joe和Ann的消息以随机、交错的顺序出现，因为它们是并发运行的。然而，在某些环境下，上述代码可能会产生如下的顺序输出：

Joe 0
Ann 0
Joe 1
Ann 1
...

这种确定性的顺序输出与我们对并发的直觉相悖。

GOMAXPROCS：控制Go运行时可用的OS线程数

导致上述程序输出呈现顺序性的关键在于Go运行时的GOMAXPROCS配置。GOMAXPROCS环境变量或runtime.GOMAXPROCS函数决定了Go调度器可以同时使用的操作系统线程数。

GOMAXPROCS = 1（默认值）： 当GOMAXPROCS设置为1时，Go调度器会将所有的goroutine多路复用到单个操作系统线程上。这意味着，尽管程序中启动了多个goroutine，它们实际上是分时复用这一个CPU核心。调度器会定期切换goroutine，但由于只有一个执行上下文，它们无法真正地并行执行，因此输出可能看起来是顺序的，尤其是在goroutine之间的工作量相对均衡时。
GOMAXPROCS > 1： 当GOMAXPROCS设置为大于1的值时，Go调度器就可以利用多个操作系统线程，从而将goroutine分配到不同的CPU核心上并行执行。这使得真正的并行计算成为可能，程序的输出也将更符合我们对并发非确定性的预期。

为了让我们的fanIn示例能够充分利用多核CPU并展现其并发特性，我们需要显式地设置GOMAXPROCS。通常，我们会将其设置为机器的CPU核心数，以最大限度地发挥硬件性能。

修正示例代码

在main函数中添加以下两行代码，即可解决上述问题：

func main() {
    rand.Seed(time.Now().UnixNano())

    // 打印当前CPU核心数
    fmt.Println("NumCPU: ", runtime.NumCPU())
    // 设置GOMAXPROCS为CPU核心数，以启用并行执行
    runtime.GOMAXPROCS(runtime.NumCPU())

    c := fanIn(boring("Joe"), boring("Ann"))
    for i := 0; i < 10; i++ {
        fmt.Println(<-c)
    }
    fmt.Println("You're both boring: I'm leaving")
}

通过runtime.GOMAXPROCS(runtime.NumCPU())，我们告诉Go运行时可以使用所有可用的CPU核心来调度goroutine。这样，Joe和Ann的boring goroutine就有机会在不同的核心上并行运行，从而导致输出的非确定*错。

注意事项

Go Playground的行为： 在Go Playground中运行代码时，GOMAXPROCS通常固定为1，这意味着即使您在代码中设置了runtime.GOMAXPROCS(runtime.NumCPU())，也可能无法观察到并行效果。这是Playground环境的限制。
迭代次数的影响： 即使GOMAXPROCS设置为1，如果循环迭代次数足够大（例如，将i
并发与并行：
- 并发（Concurrency）： 是一种程序设计的能力，能够处理多个任务。Go语言的goroutine和channel提供了强大的并发模型。即使只有一个CPU核心，也可以通过快速切换任务来模拟同时进行。
- 并行（Parallelism）： 是指多个任务在同一时间点上真正地同时执行。这需要多核CPU的支持，并通过GOMAXPROCS > 1来启用。

总结

理解runtime.GOMAXPROCS对于编写高性能的Go并发程序至关重要。虽然Go的并发模型设计得非常易用，但在多核环境中，为了充分发挥其并行处理能力，我们必须显式地配置GOMAXPROCS。通过结合多路复用模式和正确的GOMAXPROCS设置，我们可以构建出高效、响应迅速且充分利用硬件资源的Go应用程序。

# go # 操作系统 # go语言 # ai # unix # 环境变量 # 并发编程 # 循环 # 线程

返回目录在线咨询

上一篇：微信小程序页面跳转事件绑定的实例详解
下一篇：行业内常用的SEO工具有哪些_SEO优化教程

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。