Go并发与Channel：深入理解调度器行为与同步机制

本文深入探讨go语言并发模型中的核心概念：goroutine与channel。通过分析一个常见示例，揭示go调度器的非确定性行为，解释为何并发程序的执行顺序不可预测。文章将详细阐述如何利用channel进行同步通信，并提供两种实现特定并发控制模式的实用方法：等待第一个完成的任务或等待所有任务完成，以帮助开发者编写健壮且可控的并发代码。

Go语言以其内置的并发原语——Goroutine和Channel而闻名，它们使得编写并发程序变得简单而高效。然而，对于初学者来说，理解这些并发组件的实际行为，特别是Goroutine的执行顺序和Channel的同步作用，常常会遇到困惑。本文将通过一个具体示例，深入剖析Go调度器的工作原理，并演示如何正确地使用Channel和其他同步机制来控制并发程序的流程。

Goroutine与Channel：Go并发基石

在Go语言中：

• Goroutine 是一种轻量级的并发执行单元。它们由Go运行时管理，而不是操作系统线程。启动一个Goroutine非常简单，只需在函数调用前加上 go 关键字即可。Goroutine的开销极小，可以在一个程序中轻松创建成千上万个。
• Channel 是一种类型化的管道，用于Goroutine之间进行通信和同步。通过Channel，Goroutine可以安全地发送和接收数据，避免了共享内存可能带来的复杂性（如数据竞争）。Channel分为有缓冲和无缓冲两种，无缓冲Channel在发送和接收操作完成之前会阻塞，天然地提供了同步机制。

Go调度器：非确定性的幕后推手

理解Go并发的关键在于理解Go调度器。Go调度器负责将Goroutine映射到操作系统线程上执行。它的主要特点是非确定性（non-deterministic）。这意味着：

1. 无序性： 多个Goroutine的执行顺序是不可预测的。调度器会根据内部算法（如工作窃取、抢占式调度等）和系统资源情况，在不同的Goroutine之间快速切换，以实现并发执行的效果。
2. 抢占式调度： Go 1.14及更高版本引入了非协作式抢占，即使Goroutine没有主动让出CPU（例如通过Channel操作或系统调用），调度器也能在适当的时机暂停一个长时间运行的Goroutine，转而执行其他Goroutine。
3. 并行性： 在多核处理器系统上，Go调度器可以将多个Goroutine同时分配到不同的CPU核心上并行执行，进一步提高程序的吞吐量。

正是这种非确定性，导致了并发程序的输出可能在不同运行环境下有所不同，或者在同一环境下多次运行也可能产生不同的结果。

案例分析：深入理解并发行为

考虑以下Go程序，它创建了两个Goroutine，并尝试使用一个无缓冲Channel进行同步：

package main

import (
    "fmt"
    "time" // 引入time包用于模拟耗时操作
)

func display(msg string, c chan bool) {
    fmt.Println("display first message:", msg)
    c <- true // 发送数据到Channel
}

func sum(c chan bool) {
    // 模拟一个非常耗时的计算
    longSum := 0
    for i := 0; i < 10000000000; i++ {
        longSum++
    }
    fmt.Println(longSum)
    c <- true // 发送数据到Channel
}

func main() {
    c := make(chan bool) // 创建一个无缓冲的bool类型Channel

    go display("hello", c) // 启动display Goroutine
    go sum(c)              // 启动sum Goroutine

    <-c // main Goroutine从Channel接收数据
    // time.Sleep(time.Second) // 尝试添加短暂延迟，观察行为
}

代码分析：

百度作家平台

百度小说旗下一站式AI创作与投稿平台。

146

查看详情

1. main 函数创建了一个无缓冲Channel c。
2. 它启动了两个Goroutine：display 和 sum。
3. display Goroutine打印一条消息，然后向Channel c 发送一个 true 值。
4. sum Goroutine执行一个非常耗时的循环计算，打印结果，然后也向Channel c 发送一个 true 值。
5. main Goroutine执行 <-c，这意味着它会阻塞，直到从Channel c 接收到一个值。

问题与困惑： 用户观察到的输出是：

display first message: hello
10000000000

这表明 display 和 sum 两个Goroutine都完成了它们的打印操作。然而，main 函数中只有一个 <-c 接收操作。一个无缓冲Channel在没有接收者的情况下发送操作会阻塞，反之亦然。如果 main 只接收一次，那么当第一个Goroutine（无论是 display 还是 sum）成功发送数据后，main 就会被解除阻塞并继续执行，最终 main 函数返回，整个程序终止。这意味着另一个Goroutine在没有接收者的情况下尝试发送数据会永远阻塞，或者如果 main 提前退出，它可能根本没有机会完成。

深入解释： 实际上，用户观察到的输出反映了Go调度器的非确定性以及程序终止的微妙之处。

1. main 启动 display 和 sum Goroutine。
2. Go调度器开始在 main、display 和 sum 这三个Goroutine之间切换。
3. 场景一（可能导致用户观察的输出）：
   • 调度器可能先运行 display。display 打印 "display first message: hello"。
   • display 尝试执行 c <- true。此时 main 正在等待 <-c。
   • display 成功发送数据，main 接收到数据并解除阻塞。
   • 此时 main 已经不再阻塞，可以继续执行。但Go运行时可能在 main 真正退出并终止整个程序之前，仍会给其他活跃的Goroutine（如 sum）一些执行时间。
   • 如果 sum Goroutine在这段短暂的窗口期内，被调度器选中并完成了其耗时计算和打印操作，那么 10000000000 就会被打印出来。
   • 最终，main 函数返回，整个程序终止，无论 sum 是否完全完成，其他Goroutine都会被强制终止。
4. 场景二（更符合代码逻辑的常见情况）：
   • 调度器可能先运行 sum。sum 开始其漫长的计算。
   • 在 sum 计算的过程中，调度器可能会切换到 display。
   • display 打印 "display first message: hello"，然后尝试 c <- true。
   • main 接收到数据并解除阻塞，然后 main 退出。此时 sum 还没有完成计算，因此 10000000000 不会被打印。
   • 或者，sum 先完成计算并尝试 c <- true，main 接收，然后退出，display 则可能没有机会打印。

这说明了，仅仅通过一个 <-c 来同步，并不能保证所有Goroutine都能完成其任务，也不能保证特定的执行顺序。程序的最终行为高度依赖于调度器的决策和Goroutine的相对执行速度。

实现可控的并发模式

为了编写出行为可预测的并发程序，我们需要明确的同步机制。以下是两种常见的并发控制模式。

模式一：等待第一个完成的任务并退出

如果我们的目标是只关心第一个完成的任务的结果，并希望程序在获取到该结果后立即退出，那么可以通过修改Channel的用途来实现。让Goroutine将它们的“结果”发送到Channel，而不是简单的布尔值。

示例代码：

package main

import (
    "fmt"
    "time"
)

func displayResult(msg string, resultChan chan string) {
    time.Sleep(100 * time.Millisecond) // 模拟display稍作延迟
    resultChan <- "Display Goroutine: " + msg
}

func sumResult(resultChan chan string) {
    // 模拟一个非常耗时的计算
    longSum := 0
    for i := 0; i < 10000000000; i++ {
        longSum++
    }
    resultChan <- fmt.Sprintf("Sum Goroutine: %d", longSum)
}

func main() {
    resultChan := make(chan string) // 创建一个用于发送结果的string类型Channel

    go displayResult("hello", resultChan)
    go sumResult(resultChan)

    // main Goroutine等待第一个发送到resultChan的结果
    firstResult := <-resultChan
    fmt.Println("Received first result:", firstResult)

    // 此时，main函数将继续执行并退出，其他未完成的Goroutine将被终止。
    // 如果需要确保所有Goroutine都能安全退出，可以添加短暂延迟，但这不是推荐的做法。
    // time.Sleep(time.Second) // 仅为演示效果，不推荐在生产环境依赖这种方式
}

解释： 在这个模式中，main Goroutine只等待从 resultChan 接收一个值。无论是 displayResult 还是 `sumResult

以上就是Go并发与Channel：深入理解调度器行为与同步机制的详细内容，更多请关注php中文网其它相关文章！