本文章整理自——字节跳动青年训练营（第五届）后端组
1.线程和协程
操作系统中有三个重要的概念，分别是进程、线程和协程。其中进程和线程的区别请移步操作系统专栏，现在主要叙述线程和协程的区别。
简单来说，协程又称为用户态线程（以下的线程均指的是内核级线程），它比线程更加轻量化，使用起来更灵活，具有更高的性能。具体来说，协程的各种操作所需要的开销要比线程少，因此具有更高的性能。协程线程是内核态的，栈是MB级别的；协程是用户态的，其栈是KB级别的。一个线程可以控制多个协程，Go语言自动完成协程的创建，Go一次可以创建上万条协程，因此Go在针对高并发场景上有优势
Go使用如下方法创建协程
go func(形式参数){
函数体
}(实际参数)
简单来说，就是在函数func前加go关键字以创建协程
协程的简单例子如下：
import (
"fmt"
"time"
)
// 协程的简单例子
func hello(i int) {
println("Hello goroutine" + fmt.Sprint(i))
}
func main() {
for i := 0; i < 5; i++ {
// 在函数func前加go关键字以创建协程
go func(j int) {
hello(j)
}(i) //此处填入协程的实际参数
}
time.Sleep(time.Second)
}
其输入如下:
Hello goroutine1
Hello goroutine4
Hello goroutine2
Hello goroutine0
Hello goroutine3
其数字i是完全随机的，可以看出协程的并发性
2.协程的通信CSP
GO提倡通过通信共享内存而不是使用共享内存通信，两者区别如下
3.通道Channel
通道是Go进行通信的重要手段，通道的创建如下
make(chan 元素类型, [缓冲区大小]）
// example
make(chan int) //无缓冲通道
make(chan char, 2)
无缓冲通道中1发送的信息回立即传送到2中，会出现同步问题。而有缓冲的通道则会先放置到缓冲区中再送入2，带缓冲通道的可以解决一些速度不匹配问题
下面使用一个例子实现生产者消费者问题：
生产者：负责生成数字，并且将数字放入到缓冲区src中
消费者：从src中取出数字，并将其取平方
生产者消费者问题详解可以看这个：https://blog.csdn.net/weixin_45434953/article/details/127044788
package main
func main() {
src := make(chan int) // 无缓冲通道
dest := make(chan int, 3) // 缓冲区为3的通道
// 生产者协程，用于生产数字
go func() {
defer close(src)
for i := 0; i < 10; i++ {
src <- i //将数据i冲入通道src中
}
}()
// 消费者进程，取出src中的数字并且将其平方后放入dist通道
go func() {
defer close(dest)
for i := range src {
dest <- i * i //将i的平方冲入dist通道中
}
}()
for i := range dest {
println(i)
}
}
通过结果可以看出，通道可以保证输出的顺序
4.并发安全：锁Lock
使用锁可以确保对临界资源的互斥访问，从而避免同步互斥发生的数据不匹配问题，以下是一个简单的同步互斥问题：
我们需要启动5个协程，每个协程对x进行2000次+1的操作，x=x+1的操作可以分解为：1.运算器取得x的值 2.运算器执行x=x+1，并将结果写回寄存器 3.将运算器的值写回内存
import (
"sync"
"time"
)
var (
x int64
lock sync.Mutex
)
// 加锁版本
func addWithLock() {
for i := 0; i < 2000; i++ {
lock.Lock()
x += 1
lock.Unlock()
}
}
// 不加锁版本
func addWithoutLock() {
for i := 0; i < 2000; i++ {
x += 1
}
}
func main() {
x = 0
// 启动5个协程，他们需要互斥地访问x
for i := 0; i < 5; i++ {
go addWithLock()
}
time.Sleep(time.Second)
println("WithLock:", x)
x = 0
// 启动5个协程，他们不需要互斥地访问x
for i := 0; i < 5; i++ {
go addWithoutLock()
}
time.Sleep(time.Second)
println("WithoutLock:", x)
}
其输出的结果是：
WithLock: 10000
WithoutLock: 7050
分析以上代码片段：
如果使用addWithoutLock()函数，假设某时刻x=10，然后协程a执行了一次x=x+1，协程b执行了一次x=x+1，此时x的值应该是12。但是假设如下情况：协程a开始运行，根据分解操作，在执行到第二步的时候，cpu切换到执行协程b，此时协程a的寄存器中x=11，但是该值尚未写回内存，因此协程b从内存中取得的x的值还是10，进行x=x+1后，x=11并且将其写回内存，协程b执行结束，切换到未执行结束的协程a执行，此时a将寄存器中的x=11写回内存，则最终内存中x=11，显然这不是我们想要的结果，这就是同步导致的数据冲突，因此WithoutLock的结果最终是小于10000的
如果使用addWithLock函数，主要区别是，x只有在取得锁后才能对其进行操作，在进行x=x+1的之前，需要取得锁lock，执行结束后，才释放锁。这使得x=x+1的操作是一气呵成的，不会被中断的，这种又叫做原子操作。这避免了上述的状况。
5.WaitGroup
Go提供了WaitGroup来实现并发任务的同步，其中主要的三个方法：
Add(delta int) //有多少个并发的协程
Done() // 表示协程已完成，会将计数器的值-1
Wait() //在计数器为0之前，一直阻塞不向下执行
这类似于一个计数器，刚开始使用Add表示有n个协程，而Done方法表示协程已完成，会将n–，当n!=0的时候，会一直触发Wait()方法，使得程序阻塞在Wait处；当n=0的时候表示所有协程均已完成，程序会继续执行Wait之后的语句
示例如下:
import (
"fmt"
"sync"
)
func hello(i int) {
println("hello goroutine:" + fmt.Sprint(i))
}
func main() {
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()
}
这是对本文第一个例子的改写，没有使用time.Sleep(time.Second),因此性能更好
