【后端开发】字节跳动青训营之Go语言进阶与依赖管理

Go语言进阶与依赖管理

一、Go语言进阶
- [1.1 并发与并行](#1.1 并发与并行)
- [1.2 协程与线程](#1.2 协程与线程)
- [1.3 通道](#1.3 通道)
- - [1.3.1 生产消费模型](#1.3.1 生产消费模型)
- [1.4 并发安全](#1.4 并发安全)
二、依赖管理

一、Go语言进阶

Go语言一次可以创建上万个协程。

1.1 并发与并行

并发：多程序程序在单核CPU上运行。
并行：多程序程序在多核CPU上运行。

1.2 协程与线程

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

创建协程（实现快速加法）：

go 复制代码

func main() {
    for i:=0; i<10; i++ {
        go Add(i, i)
    }
}

注：提倡通过通信共享内存，而不是通过共享内存而实现通信。

1.3 通道

使用make语言创建通道。

1.3.1 生产消费模型

go 复制代码

package main

import (
	"fmt"
	"time"
)

func producer(ch chan<- int) {
	for i := 1; i <= 10; i++ {
		ch <- i
		fmt.Println("生产者生产了", i)
		time.Sleep(time.Second)
	}
	close(ch)
}

func consumer(ch <-chan int) {
	for num := range ch {
		fmt.Println("消费者消费了", num)
		time.Sleep(2 * time.Second)
	}
}

func main() {
	// 创建一个无缓冲的通道
	ch := make(chan int)
	
	// 启动生产者和消费者
	go producer(ch)
	go consumer(ch)
	
	// 等待程序执行完毕
	time.Sleep(30 * time.Second)
}

1.4 并发安全

当多个协程同时对一个变量进行操作的时候，可能会出现并发安全Lock问题，就是可能变量最后的值并不一定是希望的值。

go 复制代码

package main

import (
	"fmt"
	"time"
)

func producer(ch chan<- int) {
	for i := 1; i <= 10; i++ {
		ch <- i
		fmt.Println("生产者生产了", i)
		time.Sleep(time.Second)
	}
	close(ch)
}

func consumer(ch <-chan int) {
	for num := range ch {
		fmt.Println("消费者消费了", num)
		time.Sleep(2 * time.Second)
	}
}

func main() {
	// 创建一个无缓冲的通道
	ch := make(chan int)
	
	// 启动生产者和消费者
	go producer(ch)
	go consumer(ch)
	
	// 等待程序执行完毕
	time.Sleep(30 * time.Second)
}

在协程对变量进行操作之前应该首先获得锁。
注！在现实开发中应该尽量避免对共享内存的并发操作。

二、依赖管理

在开发大型Go项目的时候，应该将精力放在逻辑上，而不是代码的重复开发，因此就出现了各种各样的包用来实现项目的快速搭建。

bin：项目编译的二进制文件
pkg：项目编译的中间产物，用于加速编译
src：项目源码

注！通过go get/go mod命令可以获取最先的项目源码。

Go在依赖配置的时候会选择一个最低兼容版本。