Go 并发：高级用法与最佳实践

于 2024-09-24 17:44:03 发布
阅读量925 收藏 16
点赞数 20
文章标签： golang 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuhailong0511/article/details/142495782
版权

在当今的软件开发领域，并发编程已经成为提高程序性能和响应能力的关键技术。Go 语言以其简洁高效的并发模型而备受关注，为开发者提供了强大的工具来实现并发编程。本文将深入探讨 Go 并发的高级用法，展示其在不同场景下的强大功能和最佳实践。

一、Go 并发简介

Go 语言的并发模型基于 goroutine 和 channel。Goroutine 是一种轻量级的线程，可以在单个进程中并发执行。Channel 则是一种用于在 goroutine 之间进行通信的机制，可以实现同步和数据传递。

二、基本用法

以下是一个简单的 Go 并发程序示例，展示了如何使用 goroutine 和 channel：

package main

import (
    "fmt"
    "time"
)

func worker(id int, ch chan int) {
    for {
        n := <-ch
        fmt.Printf("Worker %d received %d\n", id, n)
        time.Sleep(time.Second)
    }
}

func main() {
    ch := make(chan int)
    for i := 1; i <= 3; i++ {
        go worker(i, ch)
    }
    for j := 1; j <= 10; j++ {
        ch <- j
    }
    close(ch)
}

在这个例子中，我们创建了一个 channel ch，并启动了三个 goroutine 来接收从 channel 中发送的数据。然后，我们向 channel 中发送了 10 个整数，每个 goroutine 会依次接收并打印这些整数。

三、高级用法

  1. 并发安全的数据结构

    • 在并发编程中，数据结构的并发安全是一个重要的问题。Go 语言提供了一些并发安全的数据结构，如sync.Map和sync.WaitGroup等。

    • sync.Map是一种并发安全的 map 类型，可以在多个 goroutine 中同时读写而不需要额外的锁。以下是一个使用sync.Map的示例：

         package main

   import (
       "fmt"
       "sync"
   )

   func main() {
       var m sync.Map
       // 存储键值对
       m.Store("key1", "value1")
       m.Store("key2", "value2")
       // 读取值
       value, ok := m.Load("key1")
       if ok {
           fmt.Println(value)
       }
       // 删除键值对
       m.Delete("key2")
       // 遍历 map
       m.Range(func(key, value interface{}) bool {
           fmt.Printf("%s: %s\n", key, value)
           return true
       })
   }

    • sync.WaitGroup可以用于等待一组 goroutine 完成。以下是一个使用sync.WaitGroup的示例：

         package main

   import (
       "fmt"
       "sync"
   )

   func worker(id int, wg *sync.WaitGroup) {
       defer wg.Done()
       fmt.Printf("Worker %d started\n", id)
       // 模拟一些工作
       time.Sleep(time.Second)
       fmt.Printf("Worker %d finished\n", id)
   }

   func main() {
       var wg sync.WaitGroup
       for i := 1; i <= 3; i++ {
           wg.Add(1)
           go worker(i, &wg)
       }
       wg.Wait()
       fmt.Println("All workers finished")
   }

  2. 并发控制

    • 在并发编程中，有时候需要控制并发的数量，以避免过多的 goroutine 同时运行导致系统资源耗尽。Go 语言提供了sync.WaitGroup和sync.Mutex等机制来实现并发控制。

    • sync.WaitGroup可以用于等待一组 goroutine 完成，从而控制并发的数量。以下是一个使用sync.WaitGroup进行并发控制的示例：

         package main

   import (
       "fmt"
       "sync"
   )

   func worker(id int, wg *sync.WaitGroup, ch chan struct{}) {
       defer wg.Done()
       fmt.Printf("Worker %d started\n", id)
       <-ch
       // 模拟一些工作
       time.Sleep(time.Second)
       fmt.Printf("Worker %d finished\n", id)
       ch <- struct{}{}
   }

   func main() {
       var wg sync.WaitGroup
       ch := make(chan struct{}, 2)
       for i := 1; i <= 5; i++ {
           wg.Add(1)
           go worker(i, &wg, ch)
       }
       for i := 0; i < 2; i++ {
           ch <- struct{}{}
       }
       wg.Wait()
       fmt.Println("All workers finished")
   }

    • sync.Mutex可以用于互斥锁，确保在同一时间只有一个 goroutine 可以访问共享资源。以下是一个使用sync.Mutex进行并发控制的示例：

         package main

   import (
       "fmt"
       "sync"
   )

   type Counter struct {
       value int
       mutex sync.Mutex
   }

   func (c *Counter) Increment() {
       c.mutex.Lock()
       c.value++
       c.mutex.Unlock()
   }

   func (c *Counter) Value() int {
       c.mutex.Lock()
       defer c.mutex.Unlock()
       return c.value
   }

   func main() {
       c := Counter{}
       var wg sync.WaitGroup
       for i := 1; i <= 1000; i++ {
           wg.Add(1)
           go func() {
               defer wg.Done()
               c.Increment()
           }()
       }
       wg.Wait()
       fmt.Println(c.Value())
   }

  3. 并发模式

    • Go 语言提供了一些并发模式，如生产者 - 消费者模式、流水线模式和扇出 / 扇入模式等，可以帮助我们更好地组织并发程序。

    • 生产者 - 消费者模式是一种常见的并发模式，其中生产者负责生成数据，消费者负责处理数据。以下是一个使用 channel 实现生产者 - 消费者模式的示例：

         package main

   import (
       "fmt"
       "time"
   )

   func producer(ch chan int) {
       for i := 1; i <= 10; i++ {
           fmt.Printf("Produced: %d\n", i)
           ch <- i
           time.Sleep(time.Second)
       }
       close(ch)
   }

   func consumer(id int, ch chan int) {
       for n := range ch {
           fmt.Printf("Consumer %d received: %d\n", id, n)
       }
   }

   func main() {
       ch := make(chan int)
       go producer(ch)
       for i := 1; i <= 3; i++ {
           go consumer(i, ch)
       }
       time.Sleep(15 * time.Second)
   }

    • 流水线模式是一种将多个操作串联起来的并发模式，其中每个操作都由一个 goroutine 执行。以下是一个使用 channel 实现流水线模式的示例：

         package main

   import (
       "fmt"
   )

   func producer(ch chan int) {
       for i := 1; i <= 10; i++ {
           ch <- i
       }
       close(ch)
   }

   func multiply(ch1 chan int, ch2 chan int) {
       for n := range ch1 {
           ch2 <- n * 2
       }
       close(ch2)
   }

   func printResult(ch chan int) {
       for n := range ch {
           fmt.Println(n)
       }
   }

   func main() {
       ch1 := make(chan int)
       ch2 := make(chan int)
       go producer(ch1)
       go multiply(ch1, ch2)
       printResult(ch2)
   }

    • 扇出 / 扇入模式是一种将一个任务分配给多个 goroutine 执行，然后将结果合并起来的并发模式。以下是一个使用 channel 实现扇出 / 扇入模式的示例：

         package main

   import (
       "fmt"
       "sync"
   )

   func worker(id int, in chan int, out chan int) {
       for n := range in {
           fmt.Printf("Worker %d received: %d\n", id, n)
           out <- n * 2
       }
       close(out)
   }

   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 n := range c {
                   out <- n
               }
               wg.Done()
           }(ch)
       }
       go func() {
           wg.Wait()
           close(out)
       }()
       return out
   }

   func main() {
       in := make(chan int)
       out1 := make(chan int)
       out2 := make(chan int)
       go worker(1, in, out1)
       go worker(2, in, out2)
       for i := 1; i <= 10; i++ {
           in <- i
       }
       close(in)
       result := fanIn(out1, out2)
       for n := range result {
           fmt.Println(n)
       }
   }

四、实际应用场景

  1. 网络编程

    • 在网络编程中，并发可以提高服务器的并发处理能力，同时处理多个客户端的连接。Go 语言的 net/http 包提供了一个简单易用的 HTTP 服务器框架，可以方便地实现并发的 Web 服务器。

         package main

   import (
       "fmt"
       "log"
       "net/http"
   )

   func handler(w http.ResponseWriter, r *http.Request) {
       fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:])
   }

   func main() {
       http.HandleFunc("/", handler)
       log.Fatal(http.ListenAndServe(":8080", nil))
   }

  2. 数据处理

    • 在数据处理中，并发可以提高数据处理的速度，同时处理多个数据任务。例如，可以使用 goroutine 和 channel 实现并发的数据读取、处理和写入。

         package main

   import (
       "fmt"
       "sync"
   )

   func readData(ch chan int) {
       for i := 1; i <= 10; i++ {
           ch <- i
       }
       close(ch)
   }

   func processData(in chan int, out chan int) {
       for n := range in {
           out <- n * 2
       }
       close(out)
   }

   func writeData(ch chan int) {
       for n := range ch {
           fmt.Println(n)
       }
   }

   func main() {
       dataCh := make(chan int)
       processedCh := make(chan int)
       var wg sync.WaitGroup
       wg.Add(3)
       go func() {
           defer wg.Done()
           readData(dataCh)
       }()
       go func() {
           defer wg.Done()
           processData(dataCh, processedCh)
       }()
       go func() {
           defer wg.Done()
           writeData(processedCh)
       }()
       wg.Wait()
   }

  3. 分布式系统

    • 在分布式系统中，并发可以提高系统的可扩展性和可靠性，同时处理多个节点的请求。Go 语言的net/rpc包提供了一个简单易用的 RPC 框架，可以方便地实现分布式系统中的并发通信。

         package main

   import (
       "fmt"
       "log"
       "net"
       "net/rpc"
   )

   type Args struct {
       A, B int
   }

   type Quotient struct {
       Quo, Rem int
   }

   type Arith int

   func (t *Arith) Multiply(args *Args, reply *int) error {
       *reply = args.A * args.B
       return nil
   }

   func main() {
       arith := new(Arith)
       rpc.Register(arith)
       ln, err := net.Listen("tcp", ":1234")
       if err!= nil {
           log.Fatal("listen error:", err)
       }
       for {
           conn, err := ln.Accept()
           if err!= nil {
               log.Fatal("accept error:", err)
           }
           go rpc.ServeConn(conn)
       }
   }

五、总结

Go 语言的并发模型为开发者提供了强大的工具来实现并发编程。通过掌握高级用法，如并发安全的数据结构、并发控制和并发模式等，可以更好地利用 Go 语言的并发特性，提高程序的性能和响应能力。在实际应用中，我们可以根据不同的场景选择合适的并发技术，实现高效的程序设计。同时，我们也需要注意并发编程中的一些常见问题，如竞争条件、死锁和内存泄漏等，以确保程序的正确性和稳定性。

三带俩王
关注
如何正确使用reflect：Go反射规范与最佳实践
weixin_39801169的博客
04-04 801
正确使用reflect包可以使Go程序更加灵活和强大。然而，反射机制的复杂性和潜在的性能问题要求开发者在使用时必须谨慎。通过遵循上述规范和最佳实践，我们可以确保代码的安全性、效率和可读性，从而编写出高质量的Go程序。
56、Go语言并发编程实战：核心概念与高级模式解析
silenceallat的博客
06-23 726
本文深入探讨了Go语言的并发编程，首先介绍了并发编程的核心概念，包括Go Routine、通道（Channel）和锁（Mutex）。接着，通过实战案例，如下载图片、商品秒杀和文件内容合并，详细阐述了如何在实际应用中使用Go语言的并发编程。最后，本文还介绍了工作池和生产者-消费者等高级并发模式，并给出了并发编程的最佳实践，如避免竞态条件、适当创建Go Routine和使用Context进行取消操作等。
深入理解Java虚拟机：JVM高级特性与最佳实践（第三版）对此书进行学习并精简和加入自己理解
qq_43338864的博客
01-02 1107
结合深入理解java虚拟机，各种视频和博客。。
使用Java构建高并发系统：设计模式和最佳实践
m0_57781768的博客
09-28 340
构建高并发系统是一项既有挑战又有趣的任务。通过持续学习和实践，我们可以掌握更多的技术和方法，构建出高性能、高可用性的并发系统。希望本文能帮助你更好地理解Java并发编程，并为你提供有用的知识和工具。不断实践，不断进步，未来的高并发世界等你来探索！
Go语言并发编程艺术：从基础到高级实践
明飞的博客
12-25 1033
欢迎来到本篇博客，我们将带你进入Go语言并发编程的引人入胜的艺术世界。并发是Go语言的一项强大特性，允许你以高效、可伸缩的方式处理并行任务。本博客将引导你从并发编程的基础开始，逐步深入，探讨Go语言中的并发模型、工具和最佳实践。无论你是初学者还是有经验的开发者，这里都会为你提供实用的见解，让你在Go语言的并发世界中游刃有余。
掌握Go语言邮件发送：net/smtp实用教程与最佳实践
walkskyer的博客
07-02 1054
net/smtp包是Go语言标准库中一个专门用于实现SMTP（Simple Mail Transfer Protocol，简单邮件传输协议）客户端的包。它提供了一系列的功能，使开发者能够以编程的方式发送电子邮件。通过使用这个包，开发者可以轻松实现邮件的发送功能，包括文本邮件、含附件的邮件或HTML格式的邮件。在实际开发中，net/smtp包的应用非常广泛，无论是发送系统通知邮件、用户注册验证邮件、还是营销推广邮件等，都可以通过这个包来实现。
Go开发者必读：Gin框架的实战技巧与最佳实践_gin框架实战
m0_60388292的博客
09-05 1206
go get -u gorm.io/driver/sqlite # 或者其他数据库驱动。(img-TBKuD9C2-1725476559173)](img-8sbdA1OJ-1725476559173)]// 优先级路由，确保特定路由优先匹配。// 使用正则表达式匹配URL。// 初始化数据库连接。
Go语言hash/fnv应用实战：技巧、示例与最佳实践
walkskyer的博客
04-01 1370
通过这些常见问题的解答，我们进一步了解了hash/fnv的应用场景、优势以及注意事项。hash/fnv作为一种简单高效的哈希函数，适用于广泛的开发场景，尤其是在需要快速处理大量数据时。然而，开发者在使用过程中也应根据具体的应用需求，合理选择和使用hash/fnv，确保既能发挥其性能优势，又能满足应用的安全和准确性需求。
Go开发者必读：Gin框架的实战技巧与最佳实践
成长之路
02-24 1687
在当今快速发展的互联网时代，Web开发的需求日益增长。Go语言以其简洁、高效、并发性强的特点，成为了开发者们的首选。而在Go语言的众多Web框架中，Gin无疑是其中的佼佼者。本文将深入探讨Gin框架的特性、优势以及如何利用Gin构建高性能的Web应用。
深入理解Go语言的并发编程：Goroutines与Channels.md
08-26
还涵盖了并发编程的最佳实践，如避免共享内存、选择适当的Channel缓冲、处理Goroutine的生命周期、避免死锁和活锁。同时，文章还探讨了高级并发模式，如生产者-消费者模式和Worker池模式，帮助开发者更好地设计和...
go语言高级编程_cut6zj_go语言_Go_golang_golang高级编程_
10-01
《Go语言高级编程》这本书是针对已经熟悉Go语言基础的开发者设计的，旨在深入探讨Go语言的高级特性和最佳实践。Go语言，又称Golang，是由Google开发的一种静态类型的、编译型的、并发型的、垃圾回收的、C风格的编程...
多线程编程中的***mon.base：高级用法和并发实践
[多线程编程中的***mon.base：高级用法和并发实践](https://opengraph.githubassets.com/d62805280548c76a29876ec001ca8eb07169d114db078fc0c834da4b735b6e05/wuyfCR7/ReadWriteLock-For-Python) # 1. 多线程编程...
【Go语言】深入解读Go语言中的指针，助你拨开迷雾见月明
景天科技苑
09-24 4157
在Go语言中，指针是一种特殊的变量类型，它用于存储变量的内存地址。通过指针，程序可以直接访问和修改变量的值，这在处理大型数据结构、优化内存使用和提高程序性能时非常有用。本文将结合具体案例，详细讲解Go语言中指针的用法，包括定义指针、使用指针访问和修改变量值、指针作为函数参数和返回值、指针数组和切片、结构体指针、空指针检查等。
golang cmd.exec 执行命令后报错 No such file or directory
weixin_42094764的博客
09-24 294
如果在你确定这个目录或者文件一定存在的情况下。这个问题有可能是因为exec执行的命令是管道操作或者重定向输出到文件导致的。
将 Go 作为脚本语言用及一些好用的包
编程点滴
09-23 806
创建一个新的命令对象。可以设置命令的名称、简短描述、详细描述、执行函数等。cmd.Use：设置命令的名称和用法。cmd.Short：设置命令的简短描述。cmd.Long：设置命令的详细描述。cmd.Run：设置命令的执行函数。：将多个子命令添加到根命令中。：添加一个字符串类型的命令行参数，带有短名称（-p）和长名称（–paramName）。可以指定默认值和参数描述。：添加一个整数类型的命令行参数。：添加一个布尔类型的命令行参数。：执行命令。如果命令执行过程中出现错误，会返回一个错误对象。
优化 Go 语言数据打包：性能基准测试与分析
最新发布
dsgdauigfs的博客
09-24 1045
对于序列化和反序列化在复用内存后，速度的提升非常明显，在同步的操作下，能做到 0 字节分配。异步场景下，使用 sync.Pool 内存固定字节分配（两个返回值在堆上分配）- encode_to：性能最优，几乎没有内存分配，适用于高性能要求的场景。- encode_with_pool：使用内存池优化，显著减少了时间和内存开销，适用于大多数场景。- encode：标准方法，时间和内存开销较高。
Redis系列补充：聊聊布隆过滤器（go语言实践篇）
sdgfafg_25的博客
09-24 733
本篇介绍了布隆过滤器的几种实现场景。并以火车票订单信息查询为案例进行说明，如何使用布隆过滤器避免缓存穿透，避免被恶意攻击。引迈 - JNPF快速开发平台_低代码开发平台_零代码开发平台_流程设计器_表单引擎_工作流引擎_软件架构。
go解决引入私有包报错“Repository owner does not exist“的两种方式
qq_42750608的博客
09-23 560
go解决引入私有包报错"Repository owner does not exist"的两种方式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值