依赖配置 - version开始，就开始很难听懂了，需要结合很多课后配套资料查阅很多文档和网站....然而好像没有那么多时间，一天给3小时学Go真的顶天了.....还有算法和Linux的Mysql...
这几天学Go已经把算法给挤掉了.....下步要权衡一下，好好分配下时间
目录
🐘并发编程
主要涉及，Go并发编程的相关概念
🍈并发与并行
我们两个人在吃午饭。你在吃饭的整个过程中，吃了米饭、吃了蔬菜、吃了牛肉。吃米饭、吃蔬菜、吃牛肉这三件事其实就是并发执行的。对于你来说，整个过程中看似是同时完成的的。但其实你是在吃不同的东西之间来回切换的
还是我们两个人吃午饭。在吃饭过程中，你吃了米饭、蔬菜、牛肉。我也吃了米饭、蔬菜和牛肉。我们两个人之间的吃饭就是并行的。两个人之间可以在同一时间点一起吃牛肉，或者一个吃牛肉，一个吃蔬菜。之间是互不影响的
上图并发，下图并行
并发的多个任务之间是互相抢占资源的；并行的多个任务之间是不互相抢占资源的
面试必考的：并发和并行有什么区别？-腾讯云开发者社区-腾讯云 (tencent.com)
实际开发中，并行可以理解为实现并发的一种手段
而Go语言👇，是为高并发而生的，它可以发挥多核优势，高效运行
🍈Goroutine -- 协程与线程
（1）进程是操作系统进行资源分配的基本单位
（2）线程又叫做轻量级进程，是进程的一个实体，是处理器任务调度和执行的基本单位位。它是比进程更小的能独立运行的基本单位
（3）协程，又称微线程，是一种用户态的轻量级线程
对于操作系统来说，一个任务就是一个进程（Process）。比如打开一个浏览器就是启动一个浏览器进程，打开一个记事本就启动了一个记事本进程，打开两个记事本就启动了两个记事本进程，打开一个Word就启动了一个Word进程
And...
有些进程还不止同时干一件事，比如Word，它可以同时进行打字、拼写检查、打印等事情。在一个进程内部，要同时干多件事，就需要同时运行多个“子任务”，进程内的这些“子任务”称为线程
And...
由于每个进程至少要干一件事，所以，一个进程至少有一个线程。当然，像Word这种复杂的进程可以有多个线程，多个线程可以同时执行，多线程的执行方式和多进程是一样的，也是由操作系统在多个线程之间快速切换，让每个线程都短暂地交替运行，看起来就像同时执行一样
协程最大的优势就是协程极高的执行效率
1，因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销
2，和线程切换相比，线程数量越多，协程的性能优势就越明显
3，不需要多线程的锁机制，因为只有一个线程
4，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好
Final...
所以协程的执行效率比多线程高很多。
此外，一个线程的内存在MB级别，而协程只需要KB级别
一文快速了解进程、线程与协程-腾讯云开发者社区-腾讯云 (tencent.com)
内核态与用户态
内核态运行操作系统程序，操作硬件；用户态运行用户程序。
（1）程序运行在3级特权级上时，可以称之为运行在用户态
（2）运行在0级特权级上时，称之为运行在内核态
而Go语言，一次可以创建上万个协程，这也是Go为什么更适合高并发场景的根源
代码（Go创建多个协程）
package main
import (
"fmt"
_ "fmt"
"time"
_ "time"
)
func hello(i int) {
//Sprint传入参数i的字符串形式，便于字符串相加
println("hello goroutine : " + fmt.Sprint(i))
}
// go创建协程, 即启用goroutine, 只需要在函数前增加 go 关键字
func HelloGoRoutine() {
for i := 0; i < 5; i++ { //创建5个goroutine
go func(j int) { //匿名函数接受的参数
hello(j)
}(i)
}
//保证子协程执行完之前, 主协程不退出
time.Sleep(time.Second) //使goroutine停顿1秒
}
func main() {
HelloGoRoutine()
}
//乱序输出，因为是通过并行打印的
📚Git从Github拉取代码
由于字节内部课，每个课都需要从Github拉取课程源码，怕忘了，在这里总结下
使用git从github上拉取项目到本地_51CTO博客_idea从git上拉取项目
注意！
（1）是在对应目录空白处，右键，点击“Open Git Bash Here”
（2）然后，将Github复制的代码，先git clone，再右键粘贴Paste
（3）拉取前要关闭代理👇
🍉CSP
CSP 即 Communicating Sequential Processes， “通信顺序进程”， CSP是Go语言特有的并发模型
Go的CSP并发模型，是通过goroutine和channel实现的
Go语言所提倡的是，“不要以共享内存的方式来通信，相反，要通过通信来共享内存。”
普通的线程并发模型，就是像Java、C++、或者Python，他们线程间通信都是通过共享内存的方式来进行的。非常典型的方式就是，在访问共享数据（例如数组、Map、或者某个结构体或对象）的时候，通过锁来访问
🦖Channel
Channel · Go语言中文文档 (topgoer.com)
（1）channel是一种类型，一种引用类型，你可以把它看成一个管道
（2）一种go协程用以接收或发送消息的安全的消息队列，
channel就像两个go协程之间的导管，来实现各种资源的同步
第二个参数是capacity(容量)
无缓冲通道
有缓冲通道
package main
func CalSquare() {
src := make(chan int) //无缓冲的通道
dest := make(chan int, 3) //有缓冲的通道
go func() {
defer close(src) //人物完成时关闭通道
for i := 0; i <= 10; i++ {
src <- i //子协程A将0-10数字发送到src通道中
}
}()
go func() {
defer close(dest)
for i := range src {
dest <- i * i //子协程B接收数字计算平方，并发送到dest通道
}
}()
for i := range dest {
//复杂操作...
println(i) //主协程中依次接受通道dest中数据，并打印
}
}
func main() {
CalSquare()
}
可以看到输出是有序的，因为
虽然启动了多个 goroutine 并行执行，但由于通道的同步机制，保证了数据的有序传递
🦖并发安全Lock
不加锁会输出预期外的结果（undefined），这就是并发安全问题
所以开发中，要尽量避免，对共享内存，进行非并发安全的读写操作
换言之，我们要对临界区进行权限控制
注意，sync. 需要导入包，而且需要Goland 1.3版本以上
package main
import ( //引入包
"sync"
"time"
)
var (
x int64 //声明x变量作为共享资源，用于计数
lock sync.Mutex //声明lock变量作为互斥锁，保护对x的并发访问
)
func addWithLock() {
for i := 0; i < 2000; i++ {
lock.Lock() //获取互斥锁
x += 1 //计算
lock.Unlock() //释放互斥锁
}
}
func addWithoutLock() { //没有互斥锁，直接对x进行并发访问
for i := 0; i < 2000; i++ {
x += 1
}
}
func Add() {
x = 0
for i := 0; i < 5; i++ {
go addWithoutLock() //创建5个goroutine并发执行函数
}
time.Sleep(time.Second)
println("WithoutLock:", x)
x = 0
for i := 0; i < 5; i++ {
go addWithLock() //
}
time.Sleep(time.Second)
println("Withlock:", x)
}
func main() {
Add()
}
WithoutLock: 9784
Withlock: 10000
🦖WaitGroup
深入理解 go sync.Waitgroup - 掘金 (juejin.cn)
WaitGroup是Go语言里，sync包里的结构体，用来阻塞主协程，等待所有协程执行完，是较为常见的并发控制方式
计数器：开启协程， +1；执行结束， -1
主协程阻塞知道计数器为0
package main
import ( //引入包
"fmt"
"sync"
)
func hello(i int) { //定义内部函数
println("hello goroutine : " + fmt.Sprint(i))
}
func ManyGoWait() { //并发执行多个goroutine
var wg sync.WaitGroup //创建sync.WaitGroup类型变量
wg.Add(5) //开启5个协程
for i := 0; i < 5; i++ {
go func(j int) {
defer wg.Done() //子协程，任务执行结束
hello(j)
}(i) //匿名函数, 传入索引值i
}
wg.Wait() //阻塞主程序，等待所有goroutine完成
}
func main() {
ManyGoWait()
}
🌼总结
（1）协程：Go可以通过高效调用模型，来实现协程(goroutine)
（2）通道：Go可以通过通信来共享内存，利用的就是通道(channel)
（3）Sync：包含Lock，WaitGroup等关键字，目的是实现并发安全操作，以及协程间的同步
🐅依赖管理
🌼简介 + 3个阶段
我们应该将更多精力放在应用逻辑的实现上
什么是依赖管理？
（1）依赖管理，是指在什么地方以什么形式引入外部代码
（2）没有项目任务是孤立存在的。除了第一个项目任务之外，每个任务或活动都以某种方式依赖于其他活动
Go的依赖管理经历了三个阶段👇
应用最广泛的是Go Module，依赖管理的目的是：
（1）管理不同项目依赖的版本
（2）控制依赖库的版本
环境变量Gopath
（1）项目代码直接依赖 src 下的代码
（2）go get 下载最新版本的包到 src 目录下
Go Vendor
（1）项目目录下增加vendor文件，所有依赖包，以副本形式放在 .../vendor 下
（2）依赖寻址方式：verder -> GOPATH
（3）每个项目引入一个依赖副本，解决多个项目需同一个package，的依赖冲突问题
Verdor 弊端
Vendor也只是依赖项目源码，无法具体地标识依赖了哪个版本，因此更新项目时，还是会出现依赖冲突，导致编译错误
Go module👇
（1）通过 go.mod 文件，管理依赖包版本
（2）通过 go get / go mod 指令工具，管理依赖包
最终目标：定义版本规则和管理项目依赖关系
依赖管理三要素
1，go.mod
配置文件，描述以来
2，Proxy
中心仓库管理依赖库
3，go get / go mod
本地工具
🌼依赖配置
分5个部分结合代码介绍：
go.mod -> version -> indirect -> incompatible -> 依赖图
go.mod
go.mod文件
module example.com/project/app // 替换为你自己的域名或者其他唯一标识
go 1.16
require (
github.com/example/lib1 v1.0.2 // 替换为实际的库路径和版本号
example.com/example/lib2 v1.0.0 //indirect，替换为实际的库路径和版本号
github.com/example/lib3 v0.1.0-20190725025543-5a5fe074e612 // 替换为实际的库路径和版本号
example.com/example/lib4 v0.0.0-20180306012644-bacd9c7ef1dd //indirect，替换为实际的库路径和版本号
github.com/example/lib5/v3 v3.0.2 // 替换为实际的库路径和版本号
github.com/example/lib6 v3.2.0+incompatible // 替换为实际的库路径和版本号
)
version
开始一点都听不懂了，应该是有很多前置知识的，，，算了，先听一遍，适当做做笔记先
...
语义化版本 和 基于commit的伪版本
indirect
indirect关键字，A对B直接依赖，A对C间接依赖
incompatible
（1）对于没有go.mod文件，并且主版本2+的依赖，会+incompatible
（2）主版本2+模块会在模块路径增加 /vN 后缀
依赖图
问：X项目依赖A，B两个项目，A，B分别依赖C项目的v1.3和v1.4版本，最终编译时，所使用的C项目版本为下列的哪项（单选）：
A. v1.3
B. v1.4 √
C. A用到C时v1.3，B用到C时v1.4
要选择，最低的兼容版本v1.4，且v1.3和v1.4之间肯定互相兼容的
🌼依赖分发
回源
（1）通过Github这样的第三方代码托管平台，go.mod中定义的依赖，可以直接在对应的仓库下载，来完成依赖分发。
（2）但是，直接用版本管理仓库下载依赖，存在一些问题👇
1，当软件作者直接在代码平台修改软件版本时，如果我们下次需要构建项目，会发现，之前所以来的版本丢失
2，当软件仓库被删除，依赖可用性就破坏了
3，大流量场景，增加负载
Proxy
（1）为了解决上述问题，Proxy出现了
（2）它会缓存站中的软件内容，缓存的软件版本不会改变，在源站软件删除之后依然可用
（3）使用Go Proxy后，构建时会直接从Go Proxy站点拉取依赖
变量GOPROXY
🌼工具篇：go get/mod
go get example.org/pkg + 👇
example.org是一个示例域名
go get example.org/pkg，比如go get github.com/username/repo
从github下载和安装一个包
go mod + 👇
🌳依赖管理三要素
（1）go.mod -> 配置文件，描述依赖
（2）Proxy -> 中心仓库管理依赖库
（3）go get / go mod -> 本地工具
总结
可算对Go Module有了个概念，但也只是概念，需要结合后续实际开发进行巩固
855
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
