【Go系列】 Go的高并发模式

Edward.W2024-07-16 18:31

承上启下

我们在之前已经学习了goroutine和channel的并发模式，也学会了sync库和context的控制。那么在Go里面一般都会使用哪些高并发模式呢？今天让我们在这篇文章中一起揭晓一下。

开始学习

for ... select...模式

for select模式是Go语言中处理并发的一种常见模式，它结合了for循环和select语句来处理多个channel上的通信。这种模式通常用于以下场景：

  • 同时从多个channel接收数据。
  • 在一个循环中处理多个channel上的消息，直到满足某个条件（例如接收到一个特殊的消息或达到某个截止时间）。

下面是for select模式的基本结构和用法：

基本结构
复制代码 
for {
    select {
    case <-ch1:
        // 处理从ch1接收到的数据
    case data := <-ch2:
        // 处理从ch2接收到的数据
    case ch3 <- data:
        // 向ch3发送数据
    default:
        // 当没有其他case准备就绪时执行
    }
    // 可能还有其他逻辑
    // 可以在这里检查是否应该退出循环
}

用法说明

  • 接收数据 ：在select的case子句中，你可以从多个channel接收数据。当任何一个channel准备好发送数据时，相应的case就会被执行。

  • 发送数据 ：你也可以在select的case子句中向channel发送数据。如果channel准备好接收数据，则case会被执行。

  • 默认情况 ：default子句是可选的。如果没有channel准备好通信，并且提供了default子句，则default会被执行。这可以用来防止select无限期地阻塞，如果所有channel都没有准备好。

  • 退出循环 ：通常在for循环内部，你需要检查某些条件以决定是否应该退出循环。这可以通过设置一个标志、使用context包来处理取消信号，或者在接收到特定消息时完成。

select .. timeout

select timeout模式是Go语言中处理并发时的一种常见模式，它通过在select语句中包含一个超时情况来防止goroutine无限期地等待channel操作。这种模式对于避免goroutine因等待某些可能永远不会发生的事件而永久阻塞非常有用。

基本结构

下面是select timeout模式的基本结构：

复制代码 
select {
case <-ch:
    // 当从ch接收到数据时执行
    // 处理接收到的数据
case <-time.After(timeoutDuration):
    // 当超时时间到达时执行
    // 处理超时情况
}

用法说明

  • channel操作 ：select的第一个case是正常的channel操作，可以是接收或发送数据。

  • 超时操作 ：第二个case使用了time.After函数，它返回一个在指定的持续时间timeoutDuration后发送当前时间的channel。当这个case被选中时，意味着已经超过了指定的超时时间。

  • 处理超时：当超时发生时，你可以执行一些清理工作、设置错误状态、重试操作或者直接退出goroutine。

示例

以下是一个使用select timeout模式的示例，它展示了如何在等待一个channel操作时设置超时：

复制代码 
package main

import (
    "fmt"
    "time"
)

func main() {
    ch := make(chan int)
    timeoutDuration := 2 * time.Second

    // 启动一个goroutine来模拟一个可能延迟的操作
    go func() {
        time.Sleep(3 * time.Second) // 模拟耗时操作
        ch <- 42 // 发送数据
    }()

    // 使用select timeout模式等待channel操作或超时
    select {
    case data := <-ch:
        fmt.Println("Received data:", data)
    case <-time.After(timeoutDuration):
        fmt.Println("Operation timed out")
    }

    fmt.Println("Done.")
}

在这个示例中，我们创建了一个channel ch 和一个超时时间 timeoutDuration。然后，我们启动一个goroutine来模拟一个耗时操作，该操作在3秒后向channel发送一个值。主goroutine使用select timeout模式来等待从channel接收数据或超时。由于我们设置的超时时间为2秒，而goroutine需要3秒来发送数据，因此会触发超时case。

运行这个程序，你会看到输出：

复制代码 
Operation timed out
Done.

这个模式确保了即使channel操作没有在预期的时间内完成，程序也不会无限期地等待，而是可以采取适当的超时处理措施。

Pipeline模式

Pipeline模式在Go语言中是一种处理数据流的高效并发模式，它通过将数据处理任务分解成一系列的阶段（stages），每个阶段由一组goroutine组成，这些goroutine之间通过channel连接。这种模式类似于工厂流水线，每个工人（goroutine）负责一部分工作，然后将半成品传递给下一个工人。

基本结构

Pipeline模式通常包含以下三个主要部分：

  1. 生成器（Generator）：负责生成数据，通常是一个或多个goroutine，它们将数据发送到channel。

  2. 处理器（Processor）：负责处理数据，可以是多个goroutine，每个goroutine从输入channel接收数据，处理完毕后发送到输出channel。

  3. 汇聚器（Collector）：负责收集最终结果，通常是一个或多个goroutine，它们从channel接收数据并执行最终的聚合操作。

以下是一个基本的Pipeline模式的示例：

复制代码 
package main

import "fmt"

// Generator: 生成0到9的数字
func generate(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

// Processor: 将输入的数字乘以2
func multiply(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * 2
        }
        close(out)
    }()
    return out
}

// Collector: 打印结果
func print(in <-chan int) {
    for n := range in {
        fmt.Println(n)
    }
}

func main() {
    // 创建Pipeline
    c := generate(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
    out := multiply(c)
    print(out)
}

在这个例子中，generate函数是一个生成器，它创建了一个goroutine来发送一系列数字。multiply函数是一个处理器，它创建了一个goroutine来接收这些数字，将它们乘以2，然后发送到另一个channel。最后，print函数作为汇聚器，它接收处理过的数字并打印它们。

特点

  • 并行性：每个阶段可以并行处理数据，这提高了程序的并发性能。

  • 解耦：每个阶段只关注自己的任务，并通过channel与其他阶段通信，降低了组件间的耦合。

  • 灵活性：可以很容易地向Pipeline中添加或移除阶段，只需确保每个阶段的输入输出channel匹配。

  • 可扩展性：可以通过增加更多的goroutine来扩展Pipeline的每个阶段，以处理更大的数据量。

Pipeline模式在Go语言中非常流行，因为它可以充分利用Go的并发特性来构建高效的数据处理流程。它适用于多种场景，如数据流处理、日志分析、图像处理等。

扇入和扇出模式

扇入（Fan-in）模式

扇入模式是指将多个子任务的结果汇总到一个channel中。在Go语言中，这通常是通过让多个goroutine将结果发送到同一个channel来实现的。

基本结构
复制代码 
func processTask(task Task, results chan<- Result) {
    // 处理任务并将结果发送到channel
    result := Result{}
    // ... 计算结果 ...
    results <- result
}

func fanIn(tasks []Task) []Result {
    numTasks := len(tasks)
    results := make(chan Result, numTasks) // 带缓冲的channel

    var wg sync.WaitGroup
    for _, task := range tasks {
        wg.Add(1)
        go func(t Task) {
            defer wg.Done()
            processTask(t, results)
        }(task)
    }
    wg.Wait()
    close(results)

    var resultsSlice []Result
    for result := range results {
        resultsSlice = append(resultsSlice, result)
    }
    return resultsSlice
}
使用说明
  • 结果收集：每个工作goroutine将处理结果发送到同一个channel。
  • 缓冲channel：使用带缓冲的channel来减少发送操作的阻塞。
  • 结果汇总：在所有工作goroutine完成后，关闭channel并从channel中读取所有结果。

在实际应用中，扇入和扇出模式通常结合使用。首先，使用扇出模式并行处理多个任务，然后使用扇入模式收集这些任务的结果。

示例

以下是一个结合使用扇入和扇出模式的示例：

复制代码 
package main

import (
    "fmt"
    "sync"
)

// 假设Task和Result是定义好的类型
type Task int
type Result int

func processTask(task Task, results chan<- Result) {
    // 模拟任务处理
    result := Result(task * 2)
    results <- result
}

func fanOutFanIn(tasks []Task) []Result {
    numTasks := len(tasks)
    results := make(chan Result, numTasks)

    var wg sync.WaitGroup
    for _, task := range tasks {
        wg.Add(1)
        go func(t Task) {
            defer wg.Done()
            processTask(t, results)
        }(task)
    }
    wg.Wait()
    close(results)

    var resultsSlice []Result
    for result := range results {
        resultsSlice = append(resultsSlice, result)
    }
    return resultsSlice
}

func main() {
    tasks := []Task{1, 2, 3, 4, 5}
    results := fanOutFanIn(tasks)
    fmt.Println(results)
}

在这个例子中，fanOutFanIn函数首先使用扇出模式将任务分配给多个goroutine，然后使用扇入模式收集这些goroutine的结果。每个goroutine将处理结果发送到同一个channel，主goroutine等待所有goroutine完成后关闭channel，并从channel中读取所有结果。

Futures模式

Future模式是一种并发编程模式，它允许程序在等待某个操作完成的同时继续执行其他任务。在Future模式中，一个操作（通常是耗时的）被提交执行，并立即返回一个future对象，这个对象代表了操作的结果。其他部分的程序可以继续执行，而不必等待操作完成。当需要操作的结果时，程序可以检查future对象，如果操作已完成，则直接获取结果；如果操作尚未完成，则可以阻塞等待结果。

在Go语言中，Future模式可以通过以下方式实现：

使用Channel实现Future模式

在Go中，channel经常被用来实现Future模式。以下是一个简单的例子：

复制代码 
package main

import (
    "fmt"
    "time"
)

// AsyncFunction 启动一个goroutine来执行一个耗时的操作，并返回一个channel用于获取结果
func AsyncFunction() <-chan int {
    resultChan := make(chan int)
    go func() {
        // 模拟耗时操作
        time.Sleep(2 * time.Second)
        resultChan <- 42 // 将结果发送到channel
    }()
    return resultChan
}

func main() {
    // 调用AsyncFunction，它立即返回一个channel
    future := AsyncFunction()

    // 在等待结果的同时，可以执行其他操作
    fmt.Println("Do some other work...")

    // 当需要结果时，从channel读取
    result := <-future
    fmt.Printf("The result is: %d\n", result)
}

在上面的代码中，AsyncFunction函数启动了一个goroutine来执行一个耗时的操作，并返回一个channel。主goroutine可以在等待结果的同时执行其他任务。当需要结果时，它从channel中读取。

使用sync包实现Future模式

Go语言的sync包提供了一个sync.WaitGroup类型，可以用来等待一组操作完成。虽然它不直接提供future对象，但可以用来实现类似的功能。

复制代码 
package main

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

// DoWork 启动一个goroutine来执行一个耗时的操作，并通过WaitGroup等待其完成
func DoWork(wg *sync.WaitGroup, result *int) {
    defer wg.Done()
    // 模拟耗时操作
    time.Sleep(2 * time.Second)
    *result = 42 // 设置结果
}

func main() {
    var wg sync.WaitGroup
    var result int

    wg.Add(1) // 增加WaitGroup的计数
    go DoWork(&wg, &result) // 启动goroutine

    // 在等待结果的同时，可以执行其他操作
    fmt.Println("Do some other work...")

    wg.Wait() // 等待goroutine完成
    fmt.Printf("The result is: %d\n", result)
}

在这个例子中，DoWork函数在一个新的goroutine中执行耗时的操作，并通过指针参数返回结果。sync.WaitGroup用于等待goroutine完成。在DoWork执行的同时，主goroutine可以执行其他任务。当WaitGroup.Wait()被调用时，主goroutine会阻塞，直到DoWork完成。

这两种方法都可以在Go中实现Future模式，让你能够编写更高效的并发程序。使用Future模式，你可以有效地利用并发性，避免不必要的等待，从而提高程序的响应性和吞吐量。

相关推荐
赵文宇（温玉）15 分钟前
构建内网离线的“github.com“,完美解决内网Go开发依赖
开发语言·golang·github
qq74223498420 分钟前
Python操作数据库之pyodbc
开发语言·数据库·python
Joker1008521 分钟前
仓颉自定义序列化：从原理到高性能多协议实现
开发语言
Adellle24 分钟前
2.单例模式
java·开发语言·单例模式
间彧24 分钟前
Kubernetes的Pod与Docker Compose中的服务在概念上有何异同？
后端
间彧28 分钟前
从开发到生产，如何将Docker Compose项目平滑迁移到Kubernetes？
后端
散峰而望33 分钟前
C++入门（一）（算法竞赛）
c语言·开发语言·c++·编辑器·github
间彧34 分钟前
如何结合CI/CD流水线自动选择正确的Docker Compose配置？
后端
间彧35 分钟前
在多环境（开发、测试、生产）下，如何管理不同的Docker Compose配置？
后端
间彧36 分钟前
如何为Docker Compose中的服务配置健康检查，确保服务真正可用？
后端
热门推荐
01GitHub 镜像站点02《大数据技术原理与应用》实验报告三 熟悉HBase常用操作03UV安装并设置国内源04综合整理：pdf预览显示：你尝试预览的文件可能对你的计算机有害。如果你信任此文件以及其来源，请打开此文件以看其内容，如何解决以正常预览文件05BongoCat - 跨平台键盘猫动画工具06Linux下V2Ray安装配置指南07npm使用国内淘宝镜像的方法08jdk21下载、安装（Windows、Linux、macOS）09NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南10GitLab 零基础入门指南：从安装到项目管理全流程