社区 学习 工具库 休闲
搜索
简体中文
首页 > 后端开发 > Golang > 掌握 Go 并发：高性能系统的基本模式

掌握 Go 并发：高性能系统的基本模式

Mary-Kate Olsen
发布： 2024-12-20 10:35:09
原创
817 人浏览过

Mastering Go Concurrency: Essential Patterns for High-Performance Systems

并发是 Go 设计的核心，使其成为构建高性能系统的绝佳选择。作为一名广泛使用 Go 的开发人员，我发现掌握并发模式对于创建高效且可扩展的应用程序至关重要。

让我们从基础知识开始：goroutine 和通道。 Goroutines 是由 Go 运行时管理的轻量级线程，允许我们并发执行函数。另一方面，通道为 goroutine 提供了一种通信和同步执行的方式。

这是一个使用 goroutine 和通道的简单示例：

func main() {
    ch := make(chan int)
    go func() {
        ch <- 42
    }()
    result := <-ch
    fmt.Println(result)
}
登录后复制
登录后复制

在这段代码中，我们创建一个通道，启动一个 goroutine 向该通道发送一个值，然后在 main 函数中接收该值。这演示了使用通道在 goroutine 之间进行通信的基本原理。

Go 并发工具包中最强大的功能之一是 select 语句。它允许 goroutine 同时等待多个通道操作。这是一个例子：

func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)
    go func() {
        ch1 <- 42
    }()
    go func() {
        ch2 <- 24
    }()
    select {
    case v1 := <-ch1:
        fmt.Println("Received from ch1:", v1)
    case v2 := <-ch2:
        fmt.Println("Received from ch2:", v2)
    }
}
登录后复制
登录后复制

此 select 语句将等待 ch1 或 ch2 中的值（以先到者为准）。它是管理多个并发操作的强大工具。

现在，让我们深入研究更高级的并发模式。一种常见的模式是工作池，它对于并发处理大量任务非常有用。这是一个实现：

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("Worker %d processing job %d\n", id, j)
        time.Sleep(time.Second) // Simulate work
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)

    for a := 1; a <= 9; a++ {
        <-results
    }
}
登录后复制
登录后复制

在此示例中，我们创建了一个由三个工作协程组成的池，用于处理来自通道的作业。这种模式非常适合在多个处理器之间分配工作并有效管理并发任务。

另一个强大的模式是管道，它涉及一系列通过通道连接的阶段，其中每个阶段都是一组运行相同功能的 goroutine。这是一个例子：

func gen(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func sq(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

func main() {
    c := gen(2, 3)
    out := sq(c)

    fmt.Println(<-out)
    fmt.Println(<-out)
}
登录后复制
登录后复制

该管道生成数字，对它们进行平方，然后打印结果。管道的每个阶段都在自己的 goroutine 中运行，允许并发处理。

当我们有多个 goroutine 从同一通道读取数据并执行耗时的操作时，扇出/扇入模式非常有用。下面是我们如何实现它：

func fanOut(in <-chan int, n int) []<-chan int {
    outs := make([]<-chan int, n)
    for i := 0; i < n; i++ {
        outs[i] = make(chan int)
        go func(ch chan<- int) {
            for v := range in {
                ch <- v * v
            }
            close(ch)
        }(outs[i])
    }
    return outs
}

func fanIn(chans ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    wg.Add(len(chans))
    for _, ch := range chans {
        go func(c <-chan int) {
            for v := range c {
                out <- v
            }
            wg.Done()
        }(ch)
    }
    go func() {
        wg.Wait()
        close(out)
    }()
    return out
}

func main() {
    in := gen(1, 2, 3, 4, 5)
    chans := fanOut(in, 3)
    out := fanIn(chans...)

    for v := range out {
        fmt.Println(v)
    }
}
登录后复制
登录后复制

这种模式允许我们在多个 goroutine 之间分配工作，然后将结果收集回单个通道。

在高性能系统中实现这些模式时，考虑几个因素至关重要。首先，我们需要注意我们创建的 goroutine 的数量。虽然 goroutine 是轻量级的，但创建太多会导致内存使用量和调度开销增加。

我们还需要小心潜在的死锁。始终确保通道上的每个发送操作都有相应的接收操作。在某些场景中，使用缓冲通道可以帮助防止 goroutine 发生不必要的阻塞。

并发程序中的错误处理需要特别注意。一种方法是使用专用的错误通道：

func main() {
    ch := make(chan int)
    go func() {
        ch <- 42
    }()
    result := <-ch
    fmt.Println(result)
}
登录后复制
登录后复制

这使我们能够在不阻塞工作协程的情况下处理错误。

另一个重要的考虑因素是在处理共享资源时使用互斥体。虽然通道是 goroutine 之间通信的首选方式，但互斥体有时是必要的：

func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)
    go func() {
        ch1 <- 42
    }()
    go func() {
        ch2 <- 24
    }()
    select {
    case v1 := <-ch1:
        fmt.Println("Received from ch1:", v1)
    case v2 := <-ch2:
        fmt.Println("Received from ch2:", v2)
    }
}
登录后复制
登录后复制

这个 SafeCounter 可以被多个 goroutine 同时安全地使用。

构建高性能系统时，通常需要限制并发操作的数量。我们可以为此使用信号量模式：

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("Worker %d processing job %d\n", id, j)
        time.Sleep(time.Second) // Simulate work
        results <- j * 2
    }
}

func main() {
    jobs := make(chan int, 100)
    results := make(chan int, 100)

    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    for j := 1; j <= 9; j++ {
        jobs <- j
    }
    close(jobs)

    for a := 1; a <= 9; a++ {
        <-results
    }
}
登录后复制
登录后复制

这可确保在任何给定时间运行的操作数不超过 maxConcurrent。

在高性能系统中有用的另一种模式是断路器。这可以帮助防止分布式系统中的级联故障：

func gen(nums ...int) <-chan int {
    out := make(chan int)
    go func() {
        for _, n := range nums {
            out <- n
        }
        close(out)
    }()
    return out
}

func sq(in <-chan int) <-chan int {
    out := make(chan int)
    go func() {
        for n := range in {
            out <- n * n
        }
        close(out)
    }()
    return out
}

func main() {
    c := gen(2, 3)
    out := sq(c)

    fmt.Println(<-out)
    fmt.Println(<-out)
}
登录后复制
登录后复制

此断路器可用于包装可能失败的操作，并防止系统处于压力下时重复尝试。

在处理长时间运行的操作时，使其可取消非常重要。 Go 的上下文包非常适合这个：

func fanOut(in <-chan int, n int) []<-chan int {
    outs := make([]<-chan int, n)
    for i := 0; i < n; i++ {
        outs[i] = make(chan int)
        go func(ch chan<- int) {
            for v := range in {
                ch <- v * v
            }
            close(ch)
        }(outs[i])
    }
    return outs
}

func fanIn(chans ...<-chan int) <-chan int {
    out := make(chan int)
    var wg sync.WaitGroup
    wg.Add(len(chans))
    for _, ch := range chans {
        go func(c <-chan int) {
            for v := range c {
                out <- v
            }
            wg.Done()
        }(ch)
    }
    go func() {
        wg.Wait()
        close(out)
    }()
    return out
}

func main() {
    in := gen(1, 2, 3, 4, 5)
    chans := fanOut(in, 3)
    out := fanIn(chans...)

    for v := range out {
        fmt.Println(v)
    }
}
登录后复制
登录后复制

这可以确保我们的操作在花费太长时间或我们决定从外部取消时会停止。

在高性能系统中，通常需要同时处理数据流。这是一个模式：

func worker(jobs <-chan int, results chan<- int, errs chan<- error) {
    for j := range jobs {
        if j%2 == 0 {
            results <- j * 2
        } else {
            errs <- fmt.Errorf("odd number: %d", j)
        }
    }
}
登录后复制

这种模式允许我们同时处理数据流，可能会利用多个 CPU 核心。

在 Go 中构建高性能系统时，分析代码以识别瓶颈至关重要。 Go 提供了优秀的内置分析工具：

type SafeCounter struct {
    mu sync.Mutex
    v  map[string]int
}

func (c *SafeCounter) Inc(key string) {
    c.mu.Lock()
    c.v[key]++
    c.mu.Unlock()
}

func (c *SafeCounter) Value(key string) int {
    c.mu.Lock()
    defer c.mu.Unlock()
    return c.v[key]
}
登录后复制

这将启用 pprof 分析器，您可以通过 http://localhost:6060/debug/pprof/ 访问它。

总之，Go 的并发原语和模式为构建高性能系统提供了强大的工具。通过利用 goroutine、通道和高级模式（如工作池、管道和扇出/扇入），我们可以创建高效且可扩展的应用程序。然而，明智地使用这些工具非常重要，始终考虑资源使用、错误处理和潜在竞争条件等因素。通过精心的设计和彻底的测试，我们可以充分利用 Go 并发模型的全部功能来构建健壮且高性能的系统。

我们的创作

一定要看看我们的创作：

投资者中心 | 智能生活 | 时代与回声 | 令人费解的谜团 | 印度教 | 精英开发 | JS学校

我们在媒体上

科技考拉洞察 | 时代与回响世界 | 投资者中央媒体 | 令人费解的谜团 | 科学与时代媒介 | 现代印度教

以上是掌握 Go 并发：高性能系统的基本模式的详细内容。更多信息请关注PHP中文网其他相关文章！

来源：dev.to
上一篇：如何在 Go 中分割字符串并分配变量？ 下一篇：如何在 Go 中使用“reflect.TypeOf()”执行类型断言？
本站声明
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系admin@php.cn
作者最新文章
最新问题
function_exists()无法判定自定义函数 function test()    {        return true;    }    if (function_exists('TEST')) {        ech...
来自于 2024-04-29 11:01:01
0
3
2250
google 浏览器 手机版显示的怎么实现 老师您好，google 浏览器怎么变成手机版样式的？
来自于 2024-04-23 00:22:19
0
11
2387
子窗口操作父窗口，输出没反应 前两句可执行，最后一句没法应
来自于 2024-04-19 15:37:47
0
1
1998
父窗口没有输出 document.onclick = function(){ window.opener.document.write('我是子窗口的输出');                  ...
来自于 2024-04-18 23:52:34
0
1
1885
关于CSS思维导图的课件在哪？ 课件
来自于 2024-04-16 10:10:18
0
0
1955
相关专题
更多>
热门推荐
热门教程
更多>
相关教程
热门推荐
最新课程
最新下载
更多>
网站特效
网站源码
网站素材
前端模板