Go 语言进阶与依赖管理

谁践踏了优雅 2024-03-27 12:18 68阅读 0赞

> **作者**：非妃是公主  
> **专栏**：《Golang》  
> **博客主页**：[https://blog.csdn.net/myf\_666][https_blog.csdn.net_myf_666]  
> **个性签：顺境不惰，逆境不馁，以心制境，万事可成。——曾国藩**  
> ![在这里插入图片描述][d6e10e8cd5b342e8a44dd458ee6d28f7.jpeg]  
> 
> 
> #### 文章目录 ####
> 
>  *  一、语言进阶
>  *   *  1. 并发和并行
>      *  2. 协程(Goroutine)与线程
>      *  3. CSP(Communicating Sequential Processes)
>      *  4. Channel
>      *  5. 并发安全 Lock
>      *  6. WaitGroup
>  *  二、依赖管理
>  *   *  1. GOPATH
>      *  2. Go Vendor
>      *  3. Go Module
>      *   *  Ⅰ. 依赖表述
>          *  Ⅱ. 依赖管理
>          *  Ⅲ. 本地工具
>          *   *  ① go get
>              *  ② go mod

![在这里插入图片描述][d5f52c57b26d40149fdc18207545f957.gif_pic_center]

## 一、语言进阶 ##

### 1. 并发和并行 ###

Go语言是一种并发性能很好的语言，它可以多核(多核指：一个电脑包含多个CPU)优势，更加高效地运行。  
![在这里插入图片描述][f542f09aac034dc586753b236d864487.png_pic_center_x_16]

--------------------

### 2. 协程(Goroutine)与线程 ###

Go语言的并发编程，主要就是通过协程（Goroutine）来实现的。协程和线程类似，但又并不同于线程，它比线程更加轻量级。  
![在这里插入图片描述][a7e122765d38437b846ed6ea3117de5d.png_pic_center_x_16]

协程：用户态，轻量级线程，栈KB级别；  
线程：内核态，线程跑多个协程，栈MB级别。

--------------------

### 3. CSP(Communicating Sequential Processes) ###

协程间通信与进程通信类似，主要有2种方式：

1.  通道
2.  临界区

对于这两种方式，Go语言采用第一种——通道方式，进行协程间的信息传递。即，下图中左边的这种方式：  
![在这里插入图片描述][a0a1bc9824c24b319a9fdcc420c156ae.png_pic_center_x_16]  
这样做的优点是，通过通信共享内存性能较高，不会像临界区一样，存在性能较低的问题。

### 4. Channel ###

缓冲通道：

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

它可以采用上面make的方式进行初始化，第一个参数指定类型，第二个参数指定缓冲通道的大小。

![在这里插入图片描述][c3aee2c6bc934e538bcb686ad78dbf96.png_pic_center_x_16]

一个示例代码如下：

package concurrence
    
    func CalSquare() {
        
    	src := make(chan int)
    	dest := make(chan int, 3)
    	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 {
        
    		//复杂操作
    		println(i)
    	}
    }

代码中关于defer主要用来进行延迟调用（程序执行完毕后，即将退出时，执行defer，详细的关于defer的介绍，请查看博客：[Golang中的一些关键字][Golang]），然后相当于通过src这一公共区域进行内存通信。

这个demo程序类似于生产者、消费者进程，输出结果如下：

![在这里插入图片描述][a11b8b7c70a34b77addf750d7d384a0a.png_pic_center_x_16]

### 5. 并发安全 Lock ###

锁的作用主要是用来保证在操作变量时，只有一个协程在操作，这时候另一个协程想要操作的时候，需要等待锁解除才行。这样的操作，可以保证程序执行的正确性，防止程序出错。

下面来看一个demo，这个demo的作用是执行2000次+1操作，然后采用5个协程进行。函数的定义如下。

首先，是带有锁的函数定义，在操作x的时候，锁住了lock，如下：

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

不带锁的定义，如下：

func addWithoutLock() {
        
    	for i := 0; i < 2000; i++ {
        
    		x += 1
    	}
    }

5个协程，每个执行2000次+1操作，如下：

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

运行程序如下：

![在这里插入图片描述][efb2444f6a9e42d5a8b70916208de1a6.png_pic_center_x_16]

这时，很有意思的是，并没有发生错误！本来想着由于没有加锁，这样多个进程在操作数据的时候就可能在同一个时钟周期，而造成数据丢失。

于是，我分析了一下原因，现在的CPU为16核，甚至更多，5个协程可能可以在不同的不同核上并行去跑，之间并没有影响。也就是说，会不会出错误，可能和机子的性能有关。我的机子是16核的，因此，我进行了如下尝试，修改协程数为17，果然，触发了错误，没有锁的协程产生了操作丢失。

![在这里插入图片描述][6b64413f316141c8af9c4cbe494bdde4.png_pic_center_x_16]

### 6. WaitGroup ###

相当于一个计数器，那么它的作用是什么呢？记录当前正在执行的协程数，当正在执行的线程数不为 0 的时候，就需要进行一个等待。

demo程序如下：

func ManyGoWait() {
        
    	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()
    }

其中 wg 表示创建的一个WaitGroup，通过Add可以添加一个协程数，Add可以为负数；

然后启动协程，通过延迟调用，当协程完成后，我们执行Done函数，这会对写成书 -1 。

最后通过 Wait 函数，如果正在运行的协程不为0（存在正在运行的协程），那么就不结束主进程。

关于WaitGroup的定义，可以查看源码及注释进行了解，如下：  
![在这里插入图片描述][565ad1bc942546d789bba875202c53e3.png_pic_center_x_16]

Done 和 Wait，如下：

![在这里插入图片描述][2ae7829bb4bf462eb1193b5f4409f9d9.png_pic_center_x_16]

同时，有了 `wg.Wait()` ，既可以省略了之前的 `time.Sleep(time.Second)` 了。

## 二、依赖管理 ##

随着功能的增强，同时也需要更多的依赖库，这时候，依赖管理就显得很重要了。

Golang的依赖管理按照发展历史，可分为3种，GOPATH，Go Vendor，Go Module。如下图：

![在这里插入图片描述][01fb5d05dd08462e8ec01bd68804c802.png_pic_center_x_16]

### 1. GOPATH ###

首先，值得说明的是，不同于Java、C++、python等，在Golang中，是不存在项目（project）这一概念的，在Gopath路径下就是Golang的工作目录，存在三个文件夹，作用分别如图中标注：

![在这里插入图片描述][452f499ea32a4cb2af59f82180657d4a.png_pic_center_x_16]

弊端：无法实现package的多版本控制。比如，不同的程序用到了同一个package，但是又是不同版本的，这时候，Gopath这种管理方式就无法处理了。如下：

![在这里插入图片描述][1421a2e2343c419e97e57c9df1d29447.png_pic_center_x_16]

### 2. Go Vendor ###

由于上面的弊端，诞生了Go Vendor，相当于在每个项目下，建立了一个Vendor文件夹，里面存放项目中用到的package，当程序寻找依赖报的时候，先去Vendor中去寻找，如果找不到，再去Gopath下去寻找，这就避免了上面提到的 `package版本` 问题。  
![在这里插入图片描述][1bef9ec5af544ea0b0f5d7258bc75ed7.png_pic_center_x_16]

但这种方法同样存在着较大的问题，如果一个项目（A）用到的两个包（B和C），这两个包又依赖了同一个包D，但是用到的这同一个包但是版本不同且不兼容的包D，同样回出现如下 `无法控制版本` 的问题（即项目内出现此问题）：

![在这里插入图片描述][617bb88e21da4ce581ec037e611e37aa.png_pic_center_x_16]

### 3. Go Module ###

Go Module解决了上面相同包，不同版本的问题。

和Mave很类似，其中包含三要素：

1.  配置文件，描述依赖 go.mod
2.  中心仓库管理依赖库 Proxy
3.  本地工具 go get/mod

#### Ⅰ. 依赖表述 ####

![在这里插入图片描述][c990b61e93434caf823330398af7464b.png_pic_center_x_16]

![在这里插入图片描述][09c21772f35e44d0b86ea116b5d99ca7.png_pic_center_x_16]

通过上面这两种标识，我们就可以将不同版本的包区分开来。

#### Ⅱ. 依赖管理 ####

![在这里插入图片描述][8903b4b4134c4110b515e0fff7845dda.png_pic_center_x_16]

![在这里插入图片描述][06484d771a3844eb859c13dcb7e64c56.png_pic_center_x_16]

![在这里插入图片描述][901631e725064aeda7182f232876d913.png_pic_center_x_16]

![在这里插入图片描述][a1581bf1aa324d5ebf22c403e5b2f198.png_pic_center_x_16]

#### Ⅲ. 本地工具 ####

##### ① go get #####

![在这里插入图片描述][78b40a5e526e4c76b52381596f540983.png_pic_center_x_16]

##### ② go mod #####

![在这里插入图片描述][83610f5e94f84aeab5b1862383b3d963.png_pic_center_x_16]

![在这里插入图片描述][f1a407dd99de43739ed19848884fc678.png_pic_center_x_16]

[https_blog.csdn.net_myf_666]: https://blog.csdn.net/myf_666
[d6e10e8cd5b342e8a44dd458ee6d28f7.jpeg]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/27f78f5e8bd94d22ab037ee47bbb18c0.png
[d5f52c57b26d40149fdc18207545f957.gif_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/fd4a8a4f1e594817897dd49fca34ca8b.png
[f542f09aac034dc586753b236d864487.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/e3929e6f23f0463a801c183868892b24.png
[a7e122765d38437b846ed6ea3117de5d.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/9cba4cf76c714a01b5eb48390c38c2b8.png
[a0a1bc9824c24b319a9fdcc420c156ae.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/ff8c760ffb6945fcaaf2e6b4f1eb5ddb.png
[c3aee2c6bc934e538bcb686ad78dbf96.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/09ab0045747f4f77b6126d098e2e9dd6.png
[Golang]: https://blog.csdn.net/myf_666/article/details/128730478
[a11b8b7c70a34b77addf750d7d384a0a.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/c28777c67cee4dc0aa3d742abe2f6fde.png
[efb2444f6a9e42d5a8b70916208de1a6.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/30bb14560e5648718c019204ed6b0efb.png
[6b64413f316141c8af9c4cbe494bdde4.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/2c0f6e8446fe49b9ac6eee0abd658057.png
[565ad1bc942546d789bba875202c53e3.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/2fa9e883cd1c43419d85a8d4eb2a6a98.png
[2ae7829bb4bf462eb1193b5f4409f9d9.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/3cc5729ce9334d8ba1d705dfabfe9b92.png
[01fb5d05dd08462e8ec01bd68804c802.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/0cd0b6a228f14f64846341d43952789d.png
[452f499ea32a4cb2af59f82180657d4a.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/f6d378d1af8e494599ae4442147853bb.png
[1421a2e2343c419e97e57c9df1d29447.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/730583d1d1b747928d60dd2941210b14.png
[1bef9ec5af544ea0b0f5d7258bc75ed7.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/3cbf99a6e11440f7b2d740d720fae9b5.png
[617bb88e21da4ce581ec037e611e37aa.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/368e230276dd41558149ce70bc1fc36a.png
[c990b61e93434caf823330398af7464b.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/93ddced6ccf4496e859f016cf48a0779.png
[09c21772f35e44d0b86ea116b5d99ca7.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/a93929463ea0494f98549d13bcddd01d.png
[8903b4b4134c4110b515e0fff7845dda.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/05a510160423482f8f2254a1845c9eb8.png
[06484d771a3844eb859c13dcb7e64c56.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/5b86b66cbb5f4f8ba4b77d252a5fb181.png
[901631e725064aeda7182f232876d913.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/42225430583d4532aae52f0085e9391f.png
[a1581bf1aa324d5ebf22c403e5b2f198.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/fb06e1a8f0f34c9ba5487da274f5e272.png
[78b40a5e526e4c76b52381596f540983.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/a15436bd4ea1408aa11430d5050c8e79.png
[83610f5e94f84aeab5b1862383b3d963.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/aa17191fcd5e46cdb059d8398625fe14.png
[f1a407dd99de43739ed19848884fc678.png_pic_center_x_16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/41d31b96b5474684ab0d3fb532f2f1bb.png