前言

        本系列文章参考自稀土掘金上的 【字节内部课】公开课，做自我学习总结整理。

---

Go语言并发编程

        Go语言原生支持并发编程，它的核心机制是 Goroutine 协程、Channel 通道，并基于CSP（Communicating Sequential Processes，通信顺序进程）模型。

Gorountine 协程

• 协程：用户态，轻量级的线程，栈的大小为KB级别。

• 线程：内核态，线程可以跑多个协程，栈的大小为MB级别。

        Go语言通过使用协程进行并发编程，开销极小（初始栈大小仅2KB），同时运行数量可破万。

基础语法

go hello() //执行函数
go func(){
    
}() //执行匿名函数

Channel 通道

        Go语言并发采用的是CSP模型，CSP模型的核心思想是：通过共享内存之外的通信方式来协调并发实体。

        Go语言通过Channel通道的类型安全的数据管道，用于进行协程间同步与通信。

基础语法

make(chan 元素类型,[缓冲大小])
- 无缓冲通道：make(chan int)
- 有缓冲通道：make(chan int ,2)

        虽然Go不提倡使用共享内存进行通信，但是还是保留了一些使用了共享内存的机制，例如锁机制。

简易实践

1、快速打印Hello goroutine

        通过开启协程，进行快速打印。

package main

import (
    "fmt"
    "time"
)

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

func main() {
    for i := 0; i < 5; i++ {
        go func(j int) {
            hello(j)
        }(i)
    }
    time.Sleep(time.Second)
}
/*
C:\Users\hp\Desktop\GO>go run demo1/main.go
hello:0
hello:4
hello:2
hello:3
hello:1
*/

2、通过Channel模拟生产者消费者问题

        通过创建子协程A发送0-9数字给B协程，B协程接受数字后输出数字的平方。

package main

import "fmt"

func main() {
    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 {
        fmt.Println(i)
    }
}

---

依赖管理

        Go的依赖管理演进中有三个阶段：

• GOPATH

• GoVendor

• GoModule

GOPATH

        所有项目都共享一套依赖库，没有版本隔离。

        主要方式是通过分下面三个子目录用于管理：

• src/：用于存放所有源文件，包括自己的项目和第三方库。

• pkg/：编译后存放的库文件，用于加速编译。

• bin/：可执行文件。

GoVendor（Go 1.5+以上版本）

        在项目中引入vendor目录隔离依赖，实现项目级别的依赖管理。

GoModule（Go 1.11+）

        完全摒弃掉了GOPATH，换成了基于语义化版本的管理依赖。

核心文件

1. go.mod文件：用于依赖生命清单。

2. go.sum文件：用于进行哈希校验，防止篡改。