泉州网站建设效率网络上海优化公司选哪个

Golang

预备技术

一、算法与数据结构

第1章：基础算法

https://blog.csdn.net/m0_52806260/article/details/125519736

第2章：数据结构

https://blog.csdn.net/m0_52806260/article/details/125592926

第3章：搜索与图论

https://blog.csdn.net/m0_52806260/article/details/125771347

第4章：数论

https://blog.csdn.net/m0_52806260/article/details/125843269

第5章：动态规划

https://blog.csdn.net/m0_52806260/article/details/125459689

第6章：贪心

https://blog.csdn.net/m0_52806260/article/details/125987376

第7章：算法竞赛入门

https://blog.csdn.net/m0_52806260/article/details/146226657

二、Linux操作系统与Shell编程

https://blog.csdn.net/m0_52806260/article/details/126068791

三、计算机操作系统

四、计算机组成原理

五、计算机网络

六、Docker：云原生核心技术之一

Go 开发编程实战

一、基本语法

第1章：走进Golang

第2章：变量与数据类型

第3章：运算符

第4章：流程控制

第5章：函数

第6章：错误处理

第7章：数组

第8章：切片

第9章：映射

第10章：面向对象

第11章：文件的操作

第12章：协程和管道

1. 程序、进程、线程、协程

（1）程序 (program)

• 程序是为完成特定任务、用某种语言编写的一组指令的集合,是一段静态的代码。 （程序是静态的）

（2）进程 (process)

• 是程序的一次执行过程。正在运行的一个程序，进程作为资源分配的单位，在内存中会为每个进程分配不同的内存区域。 （进程是动态的）是一个动的过程 ，进程的生命周期 : 有它自身的产生、存在和消亡的过程

（3）线程 (thread)

• 进程可进一步细化为线程， 是一个程序内部的一条执行路径。
• 若一个进程同一时间并行执行多个线程，就是支持多线程的。

（4）协程 (goroutine)

• 又称为微线程，纤程，协程是一种用户态的轻量级线程
• 作用：在执行A函数的时候，可以随时中断，去执行B函数，然后中断继续执行A函数（可以自动切换），注意这一切换过程并不是函数调用（没有调用语句)，过程很像多线程，然而协程中只有一个线程在执行（协程的本质是个单线程）

• 对于单线程下，我们不可避免程序中出现io操作，但如果我们能在自己的程序中（即用户程序级别，而非操作系统级别）控制单线程下的多个任务能在一个任务遇到io阻塞时就将寄存器上下文和栈保存到某个其他地方，然后切换到另外一个任务去计算。在任务切回来的时候，恢复先前保存的寄存器上下文和栈，这样就保证了该线程能够最大限度地处于就绪态，即随时都可以被cpu执行的状态，相当于我们在用户程序级别将自己的io操作最大限度地隐藏起来，从而可以迷惑操作系统，让其看到：该线程好像是一直在计算，io比较少，从而会更多的将cpu的执行权限分配给我们的线程（注意：线程是CPU控制的，而协程是程序自身控制的，属于程序级别的切换，操作系统完全感知不到，因而更加轻量级）

2. 协程入门

（1）案例

• 请编写一个程序，完成如下功能:
  （1）在主线程中，开启一个goroutine，该goroutine每隔1秒输出"hello golang"
  （2）在主线程中也每隔一秒输出"good bye golang"，输出10次后，退出程序
  （3）要求主线程和goroutine同时执行
• 实现代码

package mainimport ("fmt""time"
)func test() {for i := 1; i <= 10; i++ {fmt.Println("hello golang")time.Sleep(1 * time.Second) // 阻塞一秒}
}func main() {go test() // 开启一个协程：go + 函数名// 主线程for i := 1; i <= 10; i++ {fmt.Println("good bye golang")time.Sleep(1 * time.Second) // 阻塞一秒}return
}

• 运行结果

• 执行流程示意图

3. 主死从随

（1）主死从随

• 如果主线程退出了，则协程即使还没有执行完毕，也会退出
• 当然协程也可以在主线程没有退出前，就自己结束了，比如完成了自己的任务
• 验证代码

package mainimport ("fmt""strconv""time"
)func test() {for i := 1; i <= 1000; i++ {fmt.Println("hello golang" + strconv.Itoa(i))time.Sleep(1 * time.Second) // 阻塞一秒}
}func main() {go test() // 开启一个协程：go + 函数名// 主线程for i := 1; i <= 10; i++ {fmt.Println("good bye golang" + strconv.Itoa(i))time.Sleep(1 * time.Second) // 阻塞一秒}return
}

• 执行结果

4. 启动多个协程

（1）案例

package mainimport ("fmt""time"
)func main() {// 匿名函数 + 外部变量 = 闭包for i := 1; i <= 5; i++ {go func(n int) {fmt.Printf("这是%d号协程\n", n)}(i)}time.Sleep(2 * time.Second) // 避免主死从随
}

5. 使用WaitGroup控制协程退出

（1）WaitGroup的作用

WaitGroup用于等待一组线程的结束。父线程调用Add方法来设定应等待的线程的数量。每个被等待的线程在结束时应调用Done方法。同时，主线程里可以调用Wait方法阻塞至所有线程结束。—> 解决主线程在子协程结束后自动结束

（2）主要方法

（3）案例代码

• Add/Done/Wait

package mainimport ("fmt""sync"
)var wg sync.WaitGroupfunc main() {// 启动五个协程for i := 1; i <= 5; i++ {wg.Add(1) // 协程开始go func(n int) {fmt.Printf("这是%d号协程\n", n)wg.Done() // 协程结束}(i)}wg.Wait() // 阻塞等待协程全部完成
}

• 如果忘记计数器减1，可以提前defer：

package mainimport ("fmt""sync"
)var wg sync.WaitGroupfunc main() {// 启动五个协程for i := 1; i <= 5; i++ {wg.Add(1) // 协程开始go func(n int) {defer wg.Done() // 提前写defer，防止忘记计数器-1fmt.Printf("这是%d号协程\n", n)/*其余代码其余代码其余代码其余代码其余代码*/}(i)}wg.Wait() // 阻塞等待协程全部完成
}

• 可以最开始在知道协程次数的情况下先Add操作：

package mainimport ("fmt""sync"
)var wg sync.WaitGroupfunc main() {wg.Add(5) // 预先设置协程数// 启动五个协程for i := 1; i <= 5; i++ {go func(n int) {defer wg.Done() // 提前写defer，防止忘记计数器-1fmt.Printf("这是%d号协程\n", n)/*其余代码其余代码其余代码其余代码其余代码*/}(i)}wg.Wait() // 阻塞等待协程全部完成
}

注意：Add中加入的数字和协程的次数一定要保持一致

6. 多个协程操纵统一数据案例（互斥锁）

（1）案例

package mainimport ("fmt""sync"
)var totalNum int
var wg sync.WaitGroupfunc add() {defer wg.Done()for i := 0; i < 100000; i++ {totalNum++}
}
func sub() {defer wg.Done()for i := 0; i < 100000; i++ {totalNum--}
}
func main() {wg.Add(2) // 预先设置协程数// 启动五个协程go add()go sub()wg.Wait() // 阻塞等待协程全部完成sfmt.Println(totalNum)
}

• 结果：在理论上，这个totalNum结果应该是0 ，无论协程怎么交替执行，最终想象的结果就是0，但是事实上：不是

• 问题出现的原因：（图解为其中一种可能性）

• 解决问题：确保一个机制：一个协程在执行逻辑的时候另外的协程不执行 ----> 锁的机制—> 加入互斥锁

• 代码实现

package mainimport ("fmt""sync"
)var totalNum int
var wg sync.WaitGroup
var lock sync.Mutexfunc add() {defer wg.Done()for i := 0; i < 100000; i++ {lock.Lock() // 上锁totalNum++lock.Unlock() // 解锁}
}
func sub() {defer wg.Done()for i := 0; i < 100000; i++ {lock.Lock() // 上锁totalNum--lock.Unlock() // 解锁}
}
func main() {wg.Add(2) // 预先设置协程数// 启动五个协程go add()go sub()wg.Wait() // 阻塞等待协程全部完成sfmt.Println(totalNum)
}

7. 读写锁的使用

golang中sync包实现了两种锁 Mutex （互斥锁）和 RWMutex（读写锁）

（1）互斥锁

• 其中Mutex为互斥锁，Lock()加锁，Unlock()解锁，使用Lock()加锁后，便不能再次对其进行加锁，直到利用Unlock()解锁对其解锁后，才能再次加锁．适用于读写不确定场景，即读写次数没有明显的区别
• 性能、效率相对来说比较低，因为大部分场景都是读多写少

（2）读写锁

• RWMutex是一个读写锁，其经常用于读次数远远多于写次数的场景．
• 在读的时候，数据之间不产生影响，写和读之间才会产生影响

（3）案例

package mainimport ("fmt""sync""time"
)var wg sync.WaitGroup // 只定义无需赋值
// 加入读写锁：
var lock sync.RWMutexfunc read() {defer wg.Done()lock.RLock() //如果只是读数据，那么这个锁不产生影响，但是读写同时发生的时候，就会有影响fmt.Println("开始读取数据")time.Sleep(1 * time.Second)fmt.Println("读取数据成功")lock.RUnlock()
}func write() {defer wg.Done()lock.Lock()fmt.Println("开始修改数据")time.Sleep(time.Second * 5)fmt.Println("修改数据成功")lock.Unlock()
}func main() {wg.Add(6)// 启动协程 ---> 场合：读多写少for i := 0; i <= 5; i++ {go read()}go write()wg.Wait()
}

• 运行结果

8. 管道介绍

（1）管道（channel）特质介绍

• 管道本质就是一个数据结构——队列
• 数据是先进先出
• 自身线程安全，多协程访问时，不需要加锁，channel本身就是线程安全的
• 管道有类型的，一个string的管道只能存放string类型数据

9. 管道入门案例

（1）管道的定义

var 变量名 chan 数据类型

• chan管道关键字
• 数据类型指的是管道的类型，里面放入数据的类型，管道是有类型的，int类型的管道只能写入整数int
• 管道是引用类型，必须初始化才能写入数据，即make后才能使用

（2）案例

package mainimport "fmt"func main() {// 定义管道，声明管道 ---> 定义一个int类型的管道var intChan chan int// 通过make进行初始化：管道可以存放3个int类型的数据intChan = make(chan int, 3)// 证明管道是引用类型fmt.Printf("intChan：%v\n", intChan)// 向管道存放数据intChan <- 10num := 20intChan <- numintChan <- 40// 注意：不能存放大于容量的数据num1 := <-intChannum2 := <-intChannum3 := <-intChan// 输出管道的长度fmt.Printf("管道的实际长度：%v，管道的容量是：%v\n", len(intChan), cap(intChan))fmt.Println(num1)fmt.Println(num2)fmt.Println(num3)// 注意：在没有使用协程的情况下，如果管道的数据已经全部取出，那么再取就会报错：//num4 := <-intChan//fmt.Println(num4)
}

10. 管道的关闭

（1）管道的关闭

• 使用内置函数close可以关闭管道，当管道关闭后，就不能再向管道写数据了，但是仍然可以从该管道读取数据。

（2）案例

package mainimport "fmt"func main() {// 定义管道，声明管道 ---> 定义一个int类型的管道var intChan chan int// 通过make进行初始化：管道可以存放3个int类型的数据intChan = make(chan int, 3)// 在管道中存放数据：intChan <- 10intChan <- 20// 关闭管道：close(intChan)// 再次写入数据：--->报错// intChan<- 30// 当管道关闭后，读取数据是可以的：num := <-intChanfmt.Println(num)
}

11. 管道的遍历

（1）管道的遍历

• 管道支持for-range的方式进行遍历，请注意两个细节
  （1）在遍历时，如果管道没有关闭，则会出现deadlock的错误
  （2）在遍历时，如果管道已经关闭，则会正常遍历数据，遍历完后，就会退出遍历。

package mainimport ("fmt"
)func main() {// 定义管道 、 声明管道var intChan chan int// 通过make初始化：管道可以存放3个int类型的数据intChan = make(chan int, 100)for i := 0; i < 100; i++ {intChan <- i}// 在遍历前，如果没有关闭管道，就会出现deadlock的错误// 所以我们在遍历前要进行管道的关闭close(intChan)// 遍历：for-rangefor v := range intChan {fmt.Println("value = ", v)}
}

12. 协程和管道协同工作的案例

13. 声明只读只写管道

14. 管道的阻塞

15. select功能

16. defer + recover机制处理错误

第13章：网络编程

第14章：反射

二、Golang进阶 - 网络通信

三、Golang进阶 - 并发编程

Go Web开发之前端技术实战

一、Go Web前置 - Go Module

二、Go Web前置 - HTML

三、Go Web前置-CSS

四、Go Web前置-JS

五、Go Web前置-JQuery

六、前端技术之Vue框架

GORM及数据库

一、GORM前置：MySQL

二、MySQL性能调优与架构设计

三、GORM

Go开发应用中间件

一、Redis_高效的NoSQL数据库

二、Redis缓存数据库进阶

三、Redis之go编程实战

四、消息中间件-Kafka实战

五、Kafka之go编程实战

六、RocketMQ基础实战版

七、NoSQL-MongoDB实战

八、分布式文件存储系统Minio

全文检索 ES

一、Elasticsearch核心知识篇

Go Web开发之企业级框架

一、Web框架

二、Gin深入实战

三、Beego框架开发实战

四、微服务架构

五、Go框架开发

六、Kong入门与实战

七、Logrus日志

企业级项目实战