Go语言并发编程及依赖管理

news2024/11/29 7:59:23

🧡并发编程

Goroutine

💌 为什么 Go 语言运行效率如此之高呢？因为它可以充分发挥多核优势，这里有个重要的概念：Goroutine（协程），Go 语言是利用协程达到高并发效果的。

进程：程序一次动态执行的过程，操作系统资源分配最小单位，有独立内存空间。
线程：轻量级进程，CPU调度的最小单位，多个线程共享所属进程的资源，MB级别。
协程：轻量级线程，由用户控制调度，KB级别。

💌 如何开启一个协程呢？我们只需要在调用的函数前面添加 go 关键字，就能使这个函数以协程的方式运行。

package main

import (
   "fmt"
   "time"
)

func hello(i int) {
   println("hello goroutine:" + fmt.Sprint(i))
}

func main() {
   for i := 0; i < 5; i++ {
      go hello(i) // go + 调用函数名(参数)
   }
   time.Sleep(time.Second) // 阻塞，保证子协程执行完之前主线程不退出
}

可以看到打印结果是并发乱序输出的：

CSP(Communicating Sequential Processes)

💌 Go 语言中协程之间的通信提倡通过通信共享内存，而非通过共享内存实现通信，二者都支持实现，但是听起来很容易混淆，通过画图可以直观演示：

🍠 通过通信共享内存：通过通道给目标协程发送信息。Channel（通道）分为无缓冲通道和有缓冲通道，构造方式：

无缓冲通道：make(chan int)
有缓冲通道：make(chan int,2)

如下代码所示，构造生产者A和消费者B可以实现有缓冲通道的协程通信，生产者产生数字，消费者计算数字的平方，并顺序打印。

package main

func CalSquare() {
   src := make(chan int)     // 生产者
   dest := make(chan int, 3) // 消费者，带缓冲区
   go func() {               // A协程发送0~9至src中
      defer close(src) // defer表示延迟到函数结束时执行，用于释放已分配的资源
      for i := 0; i < 10; i++ {
         src <- i
      }
   }()
   go func() { // B协程计算src中数据的平方，并发送至dest中
      defer close(dest)
      for i := range src {
         dest <- i * i
      }
   }()
   for i := range dest {
      println(i)
   }
}

func main() {
   CalSquare()
}

🍠 通过共享内存通信：需要通过 sync 包中的 lock 进行加锁，如果不加锁会出现问题。如下代码开启5个协程，每个协程进行2000次+1操作，正确结果应该是10000，不加锁的结果不准确。项目中应避免对共享内存进行非并发安全的读写操作。

package main

import (
   "sync"
   "time"
)

var (
   x    int64
   lock sync.Mutex
)

func addWithLock() {
   for i := 0; i < 2000; i++ {
      lock.Lock() // 加锁
      x += 1
      lock.Unlock() // 解锁
   }
}

func addWithoutLock() { // 不使用锁
   for i := 0; i < 2000; i++ {
      x += 1
   }
}

func Add() {
   x = 0
   for i := 0; i < 5; i++ {
      go addWithoutLock()
   }
   time.Sleep(time.Second)
   println("WithoutLock x =", x)
   x = 0
   for i := 0; i < 5; i++ {
      go addWithLock()
   }
   time.Sleep(time.Second)
   println("WithLock x =", x)
}

func main() {
   Add()
}

💌 sync 包中的 WaitGruop 也可以实现并发任务同步，Add(delta int) 开启 delta 个协程，Done() 结束协程，Wait() 阻塞主线程。

🧡依赖管理

依赖演变

💌 Go 依赖主要经历了 GOPATH -> Go Vendor -> Go Module 演变，现在主要采用 Go Module 方式。不同环境（项目）依赖的版本不同，需要控制依赖库的版本。

GOPATH：环境变量，Go 语言的工作区，通过 go get 下载最新版本的包到 src 目录下，项目代码直接依赖 src 下的所有源代码。但是有一个弊端就是无法实现package的多版本控制，A、B 项目可能依赖同一个包的不同版本。
Go Vendor：在项目目录下新增 vendor 文件夹，所有依赖包副本形式放在其中，通过 vendor => GOPATH 的方式寻址。但是还有问题就是更新项目时可能出现依赖冲突，依然无法控制依赖的版本。
Go Module：通过 go.mod 文件管理依赖包版本，通过 go get/go mod 指令工具管理依赖包。既能定义版本规则，又能管理项目依赖关系。

依赖管理三要素

🍠 配置依赖 go.mode

module example/project/app //依赖管理基本单元

go 1.16  //原生库版本

require (  
    //单元依赖标识语法：[Module Path][Version/Pseudo-version]
    example/lib1 v1.0.2
    example/lib2 v1.0.0 // indirect
    example/lib3 v0.1.0-20190725025543-5a5fe074e612
    example/lib4 v0.0.0-20180306012644-bacd9c7ef1dd // indirect
    example/lib5/v3 v3.0.2  // 主版本2+的模块会在路径后增加/vN后缀
    example/lib6 v3.2.0+incompatible  // 对于没有go.mod文件且主版本2+的依赖+incompatible
)