Go GMP：并发编程实践

在这里插入图片描述
💝💝💝欢迎莅临我的博客，很高兴能够在这里和您见面！希望您在这里可以感受到一份轻松愉快的氛围，不仅可以获得有趣的内容和知识，也可以畅所欲言、分享您的想法和见解。

推荐:「stormsha的主页」👈，持续学习，不断总结，共同进步，为了踏实，做好当下事儿~
专栏导航
- Python系列: Python面试题合集，剑指大厂
- Git系列: Git操作技巧
- GO系列: 记录博主学习GO语言的笔记，该笔记专栏尽量写的试用所有入门GO语言的初学者
- 数据库系列: 详细总结了常用数据库 mysql 技术点,以及工作中遇到的 mysql 问题等
- 运维系列: 总结好用的命令，高效开发
- 算法与数据结构系列: 总结数据结构和算法,不同类型针对性训练,提升编程思维
非常期待和您一起在这个小小的网络世界里共同探索、学习和成长。💝💝💝 ✨✨ 欢迎订阅本专栏 ✨✨

💖The Start💖点点关注，收藏不迷路💖
📒文章目录
- - Goroutine：轻量级线程
  - - Goroutine的创建与调度
    - Goroutine的同步与通信
  - Mutex：互斥锁
  - - Mutex的使用
  - Pool：资源池
  - - Pool的工作原理
    - Pool的使用
  - 并发模式：GMP
  - - GMP模式的应用
  - 总结

内容内容内容内容内容内容内容内容内容内容内容内容内容内容内容内容内容内容内容
Go语言，以其简洁、高效和并发性能而闻名于世，是现代软件开发中不可或缺的一部分。Go的并发模型，Goroutine和Channel，是其核心特性之一。本文将深入探讨Go的并发编程模型，特别是GMP（Goroutine、Mutex、Pool）模式的使用技巧，旨在帮助开发者更好地理解和应用Go的并发特性。

Goroutine：轻量级线程

Go的Goroutine是一种轻量级的线程，由Go运行时管理。与传统的线程相比，Goroutine的创建和调度成本极低，这使得Go非常适合构建高并发的应用程序。

Goroutine的创建与调度

创建Goroutine非常简单，只需使用go关键字即可：

go myFunction()

Go运行时会为每个Goroutine分配一个很小的栈空间，并在必要时自动进行栈扩展。这种设计使得Goroutine的创建和切换非常快速。

Goroutine的同步与通信

Goroutine之间通过Channel进行通信。Channel可以看作是Goroutine之间的消息队列，用于在它们之间传递数据。使用Channel可以实现同步执行和数据共享。

ch := make(chan int)
go func() {
    ch <- 42
}()
v := <-ch

Mutex：互斥锁

在并发编程中，数据竞争是一个常见问题。Go提供了Mutex（互斥锁）来解决这个问题。Mutex确保同一时间只有一个Goroutine可以访问共享资源。

Mutex的使用

使用Mutex时，需要先通过sync.Mutex创建一个互斥锁实例，然后在访问共享资源之前调用Lock方法，访问完毕后调用Unlock方法释放锁。

var mu sync.Mutex
var shared int

func increment() {
    mu.Lock()
    shared++
    mu.Unlock()
}

Pool：资源池

Go的Pool是一种用于缓存和重用资源的机制，可以减少资源的创建和销毁开销，提高程序性能。

Pool的工作原理

Pool维护了一个资源列表，当需要资源时，可以从Pool中获取，使用完毕后归还。如果Pool中的资源不足，可以创建新的资源。

Pool的使用

创建一个Pool非常简单，使用sync.Pool即可：

p := sync.Pool{
    New: func() interface{} {
        return new(MyType)
    },
}

使用Pool时，可以通过Get方法获取资源，使用完毕后通过Put方法归还。

v := p.Get().(*MyType)
// 使用v进行操作
p.Put(v)

并发模式：GMP

结合Goroutine、Mutex和Pool，我们可以构建高效且安全的并发应用程序。GMP模式是一种常见的并发编程模式，它利用了Go的这些特性来实现高效的并发处理。

GMP模式的应用

假设我们有一个需要并发处理大量数据的任务，我们可以创建一个Goroutine池来并发处理数据，使用Mutex来保护共享资源，使用Pool来管理资源的创建和销毁。

func process(data []int, ch chan int) {
    for _, v := range data {
        // 处理数据
        ch <- v
    }
    close(ch)
}

func main() {
    var wg sync.WaitGroup
    data := make([]int, 10000)
    ch := make(chan int, 10000)
    p := &sync.Pool{
        New: func() interface{} {
            return new(int)
        },
    }

    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            defer wg.Done()
            for v := range ch {
                // 使用Pool获取资源
                pVal := p.Get().(*int)
                *pVal = v
                // 处理逻辑
                // ...
                // 使用完毕后归还资源
                p.Put(pVal)
            }
        }()
    }

    go func() {
        for _, v := range data {
            go func(v int) {
                wg.Add(1)
                defer wg.Done()
                process([]int{v}, ch)
            }(v)
        }
        wg.Wait()
        close(ch)
    }()

    wg.Wait()
}