文章目录

[Go 语言进阶与依赖管理 | 青训营](#Go 语言进阶与依赖管理 | 青训营)

Go 语言进阶与依赖管理 | 青训营

GO语言工程实践课后作业：实现思路、代码以及路径记录

语言进阶

Go可以充分发挥多核优势，高效运行

Goroutine 是Go语言中的协程，一种轻量级的线程，由Go语言的运行时管理，可以实现高并发的程序设计，由于轻量级的特性，goroutine可以创建成千上万个，而且消耗的资源也相对较少。

在函数前加入go关键字，为一个函数创建协程运行

go 复制代码

package main

import (
   "fmt"
   "time"
)

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

func HelloGoRoutine() {
   for i := 0; i < 5; i++ {
      go func(j int) {
         hello(j)
      }(i) // 向函数传入i参数，作为j的值
   }
   time.Sleep(time.Second)
}

func main() {
   HelloGoRoutine()
}

/*
 * hello goroutine : 4
 * hello goroutine : 2
 * hello goroutine : 1
 * hello goroutine : 3
 * hello goroutine : 0
 */

运行结果是乱序的表示是并行运行的

CSP(Communicating Sequential Processes)通信顺序进程,是Go语言中重要的并发模型。

主要特征有

顺序进程：每个进程内部按顺序执行。
通信进程：进程间通过通信(Message Passing)来协作。
数据流：程序通过在进程间传递数据来工作。

Go语言的CSP实现主要通过goroutine和channel

goroutine作为顺序执行的进程
channel用于goroutine间的通信

无缓冲通道（同步通道）

在Go语言中，通过通信来共享内存是一种并发编程的思想，即通过goroutine之间的通信来进行数据共享，而不是直接共享内存空间。

具体来说，当多个goroutine需要共享数据时，传统的做法是使用共享内存的方式，即使用互斥锁等机制来控制对共享变量的访问。但在Go语言中，引入了一种更优雅的方式，即使用通道（channel）来实现数据共享。

go 复制代码

package main

import "fmt"

func CalSquare() {
   src := make(chan int)     //   生产无缓冲
   dest := make(chan int, 3) //   消费缓冲3个元素
   
   // 子协程发送0-9数字
   go func() {
      defer close(src)
      for i := 0; i < 10; i++ {
         src <- i
      }
   }()

   // 子协程计算输入数字的平方
   go func() {
      defer close(dest)
      for i := range src {
         dest <- i * i
      }
   }()

   // 主协程输出最后的平方数
   for i := range dest {
      // 复杂操作
      // ...
      fmt.Println(i)
   }

}

func main() {
   CalSquare()
}

sync.WaitGroup 是Go语言中的一个常用同步工具，可以用于等待一组goroutine结束。

内部维护了一个计数器，暴露add done wait三个方法

之前例子的优化

go 复制代码

/*
 * @Author: NEFU AB-IN
 * @Date: 2023-08-24 15:15:22
 * @FilePath: \GoTest\11\11.go
 * @LastEditTime: 2023-08-24 15:17:01
 */
package main

import (
	"fmt"
	"sync"
)

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

func HelloGoRoutine() {
	var wg sync.WaitGroup
	wg.Add(5)
	for i := 0; i < 5; i++ {
		go func(j int) {
			defer wg.Done()
			hello(j)
		}(i)
	}
	wg.Wait()
}

func main() {
	HelloGoRoutine()
}

/*
 * hello goroutine : 4
 * hello goroutine : 2
 * hello goroutine : 1
 * hello goroutine : 3
 * hello goroutine : 0
 */

依赖管理

原生SDK（Software Development Kit）是指为特定操作系统或平台开发应用程序的软件工具包。它包含了一系列的开发工具和文档，用于帮助开发人员创建、测试和部署应用程序。原生SDK通常由操作系统或平台的开发者提供，可以让开发者利用操作系统或平台的特定功能和特性，开发高性能、可靠的应用程序。

go path

弊端：无法实现package多版本控制

go vendor

弊端：依赖关系隐藏在vendor中，理解和维护都更困难。依赖关系隐藏在vendor中，理解和维护都更困难。

go moudle

(类似于Java里的maven)

${major}.${minor}.${patch}

major为大版本，patch为bug修复版本，如v1.3.0

依赖图

保证v1.3和v1.4是兼容的

依赖分发 - go proxy

其实是个服务站点(中心仓库管理依赖库)，缓存仓库和版本，直接从proxy拉取依赖

GOPROXY 是用逗号分隔的URL列表

go get

下载包的源码
解压到GOPATH下
解析并下载依赖
缓存各版本的依赖
会更新go.mod文件

go mod

init
download
tidy

测试

单元测试

比如

go 复制代码

func Add(a int, b int) int{
  return a+b
}

func TestAdd(t *testing.T) {
  output:=Add(1, 2)
  expectOutput:=3
  if output != expectOutput{
    t.Error("Add failed")
  }
}

运行go test xxx.go 即可

assert

Go语言内置的testing包提供了assert包来进行单元测试的断言，assert能大大简化测试代码，不需要过多的if条件判断，只要最终结果不符合断言,就会自动标记为测试失败。

go 复制代码

package Test

import (
   "github.com/stretchr/testify/assert"
   "testing"
)

func Add(a int, b int) int {
   return a + b
}

func TestAdd(t *testing.T) {
   output := Add(1, 2)
   expectOutput := 3
   assert.Equal(t, expectOutput, output)
}

覆盖率

当一个程序有多个分支时，就会产生多种测试案例，如果所有的测试案例都符合结果，那覆盖率就是100%。
运行 go test xxx.go --cover，可以查看测试的覆盖率。
一般覆盖率在50%~60%，较高覆盖率在80%+
测试分支相互独立，全面覆盖

Mock测试

如果有一些外部依赖，可以通过mock实现

mock函数是用来模拟或替代指定函数的行为，以便在测试中控制函数的返回值或行为。

打桩是指在测试过程中为函数设置预期的返回值或行为，以确保测试代码的可重复性和可控性。通常使用mock函数来进行打桩操作，通过设置mock函数的返回值或行为，模拟特定情况下函数的行为，以便进行测试或验证。

基准测试

分析系统性能时，在本地会比较方便

基准测试是一种评估计算机系统、硬件或软件性能的方法。它通过运行一系列标准化的测试程序，以衡量系统在特定负载条件下的表现，从而提供了系统性能的参考标准或基准值。基准测试可以用于比较不同硬件或软件配置之间的性能差异，优化系统性能，或者评估系统变化对性能的影响。

基准测试通常涉及多个方面的测试，包括计算能力、内存管理、磁盘或存储访问、网络吞吐量等，并通过测量和记录相关性能指标，如处理速度、响应时间、吞吐量等来评估系统的性能。基准测试可以在实验室环境中进行，也可在真实场景中进行。

基准测试的结果可以用于为购买决策提供参考，评估系统在实际使用中的适应性，或者用于系统优化和调整，以达到更好的性能和效率。基准测试在计算机硬件和软件开发、系统管理和性能优化等领域都有广泛的应用。