Go语言并发中 time.Sleep 的行为解析

理解Go语言的并发模型与Goroutine

go语言以其内置的并发原语而闻名，其中goroutine是其核心。goroutine是一种轻量级的执行线程，由go运行时管理。通过在函数调用前加上go关键字，即可启动一个新的goroutine。与传统操作系统线程不同，goroutine的创建和销毁开销极小，可以轻松创建成千上万个goroutine。

并发（Concurrency）是指能够同时处理多个任务的能力，这些任务可能在同一时间段内交错执行。Go的运行时调度器负责在可用的CPU核心上调度这些Goroutine，使得它们看起来是并行执行的，即使在单核处理器上也是如此。

time.Sleep 的作用机制

time.Sleep(d Duration)函数的作用是暂停当前Goroutine的执行，持续时间为d。这里的“当前Goroutine”是关键，它指的是调用time.Sleep的那个特定的Goroutine，而不是整个程序或所有其他Goroutine。当一个Goroutine进入睡眠状态时，Go调度器会将CPU资源分配给其他可运行的Goroutine，从而实现高效的资源利用。

并发场景下 time.Sleep 的行为分析

许多初学者在并发编程中可能会对time.Sleep的行为产生误解。例如，如果启动N个Goroutine，每个Goroutine都调用time.Sleep(4 * time.Second)，那么程序的总执行时间是多少？直观上，有些人可能认为总时间会是N * 4秒，因为每个Goroutine都要等待。然而，在Go的并发模型下，实际的总执行时间将约等于4秒。

这是因为当主Goroutine通过一个循环启动多个工作Goroutine时，所有工作Goroutine几乎是同时启动的。一旦它们各自执行到time.Sleep(4 * time.Second)这一行，它们便会同时进入睡眠状态。Go调度器会暂停这些Goroutine，并在4秒后将它们唤醒。由于它们同时开始睡眠，也就会同时被唤醒并继续执行，因此从外部观察，整个过程的总耗时就是单个Goroutine的睡眠时长。

立即学习“go语言免费学习笔记（深入）”；

让我们通过一个具体的代码示例来演示这一行为：

package main

import (
    "fmt"
    "strconv"
    "sync"
    "time"
)

// worker函数模拟一个需要执行任务并暂停的Goroutine
func worker(id int, wg *sync.WaitGroup) {
    defer wg.Done() // 在Goroutine退出时通知WaitGroup完成

    fmt.Printf("Goroutine %d: 在 %s 开始执行任务并睡眠。\n", id, time.Now().Format("15:04:05.000"))
    time.Sleep(4 * time.Second) // 每个Goroutine睡眠4秒
    fmt.Printf("Goroutine %d: 在 %s 睡眠结束，任务完成。\n", id, time.Now().Format("15:04:05.000"))
}

func main() {
    const numWorkers = 3 // 定义启动的工作Goroutine数量
    var wg sync.WaitGroup // 用于等待所有Goroutine完成

    fmt.Printf("主Goroutine: 在 %s 启动所有工作Goroutine...\n", time.Now().Format("15:04:05.000"))
    startTime := time.Now() // 记录开始时间

    // 启动多个工作Goroutine
    for i := 1; i <= numWorkers; i++ {
        wg.Add(1) // 每启动一个Goroutine，WaitGroup计数器加1
        go worker(i, &wg)
    }

    wg.Wait() // 等待所有工作Goroutine完成

    endTime := time.Now() // 记录结束时间
    fmt.Printf("主Goroutine: 在 %s 所有工作Goroutine完成。总耗时：%v\n", endTime.Format("15:04:05.000"), endTime.Sub(startTime))
}

代码解析：

启科网络PHP商城系统

启科网络商城系统由启科网络技术开发团队完全自主开发，使用国内最流行高效的PHP程序语言，并用小巧的MySql作为数据库服务器，并且使用Smarty引擎来分离网站程序与前端设计代码，让建立的网站可以自由制作个性化的页面。 系统使用标签作为数据调用格式，网站前台开发人员只要简单学习系统标签功能和使用方法，将标签设置在制作的HTML模板中进行对网站数据、内容、信息等的调用，即可建设出美观、个性的网站。

0

查看详情

1. worker 函数： 这是一个简单的函数，它接收一个id用于标识Goroutine，以及一个*sync.WaitGroup指针用于通知主Goroutine其完成状态。它会打印开始信息，然后调用time.Sleep(4 * time.Second)，最后打印结束信息。
2. main 函数：
   • 定义了numWorkers为3，表示将启动3个工作Goroutine。
   • 创建了一个sync.WaitGroup实例wg，用于协调主Goroutine和工作Goroutine的执行。wg.Add(1)在启动每个Goroutine前增加计数器，defer wg.Done()在每个Goroutine结束时减少计数器。wg.Wait()会阻塞主Goroutine，直到计数器归零。
   • 记录了程序开始时间startTime。
   • 通过一个for循环，使用go worker(i, &wg)启动了numWorkers个并发的Goroutine。
   • 调用wg.Wait()等待所有工作Goroutine完成。
   • 记录程序结束时间endTime，并计算总耗时。

预期输出分析：

运行上述代码，你将观察到类似以下输出（时间戳会有所不同）：

主Goroutine: 在 10:30:00.000 启动所有工作Goroutine...
Goroutine 1: 在 10:30:00.000 开始执行任务并睡眠。
Goroutine 2: 在 10:30:00.000 开始执行任务并睡眠。
Goroutine 3: 在 10:30:00.000 开始执行任务并睡眠。
Goroutine 1: 在 10:30:04.000 睡眠结束，任务完成。
Goroutine 2: 在 10:30:04.000 睡眠结束，任务完成。
Goroutine 3: 在 10:30:04.000 睡眠结束，任务完成。
主Goroutine: 在 10:30:04.000 所有工作Goroutine完成。总耗时：4.00xxxxxxs

从输出中可以清晰地看到：

• 所有Goroutine几乎在同一时刻（10:30:00.000）开始睡眠。
• 所有Goroutine也几乎在同一时刻（10:30:04.000）结束睡眠。
• 主Goroutine报告的总耗时大约是4秒，而不是3 * 4 = 12秒。

这完美地印证了time.Sleep在并发Goroutine中是独立且同时作用的。

注意事项与总结

1. 独立暂停： time.Sleep只暂停调用它的那个Goroutine，不会影响其他并发运行的Goroutine。
2. 并发效率： Go的并发模型设计初衷就是为了高效地执行独立任务。time.Sleep的这种行为正是并发效率的体现，它允许其他Goroutine在当前Goroutine睡眠时继续工作，而不是等待它完成。
3. 避免误解： 如果你的程序逻辑需要Goroutine按顺序暂停或等待更长时间，那么需要显式地通过通道（chan）、互斥锁（sync.Mutex）或sync.WaitGroup等同步机制来协调它们的执行顺序和时间。例如，如果希望每个Goroutine的睡眠是串行的，那么就不应该并发启动它们，或者通过通道进行逐个信号通知。
4. 实际应用： 在实际开发中，time.Sleep常用于模拟耗时操作、定时任务或在测试中引入延迟。理解其在并发环境下的行为对于正确设计和调试并发程序至关重要。

总之，Go语言的time.Sleep在并发Goroutine中表现为独立且同时的暂停。这一特性是Go并发模型的基础，理解它有助于开发者更有效地利用Goroutine构建高性能、响应迅速的应用程序。

以上就是Go语言并发中 time.Sleep 的行为解析的详细内容，更多请关注php中文网其它相关文章！