Go

1.GMP调度原理（这部分多去看看golang三关加深理解）

Go的GMP调度模型是其并发实现的核心。

• G (Goroutine): 代表一个协程，是Go语言中并发执行的基本单元。它非常轻量，初始栈空间很小，可以创建成千上万个。
• M (Machine): 代表一个内核线程 (OS Thread)，是真正执行代码的实体。M的数量通常不会太多。
• P (Processor): 代表一个调度处理器，或者说是G和M之间的调度上下文。P的数量默认等于CPU核心数，可以通过GOMAXPROCS环境变量或运行时函数来设置。

调度流程可以概括为：

1. 每个P会维护一个可运行的G队列 (Local Run Queue, LRQ)。

2. M需要获取一个P才能执行G。M会从其绑定的P的LRQ中获取G并执行。

3. 如果P的LRQ为空，M会尝试从全局G队列 (Global Run Queue, GRQ)或其他P的LRQ中窃取 (Work Stealing) G来执行，以实现负载均衡。

4. 当G执行系统调用或发生阻塞时，它所占用的M会和P解绑（Hand Off），P会去寻找其他空闲的M，或者创建一个新的M来继续执行队列中的其他G。阻塞的G结束后会尝试重新进入某个P的队列等待执行。

5. 通过这种方式，GMP模型实现了高效的用户态调度，避免了频繁的内核态线程切换，并能充分利用多核CPU资源。

2.GC（同样多去看看golang三关加深理解）

Go语言的垃圾回收 (GC) 主要是为了自动管理内存，减轻开发者的负担，避免内存泄漏。

Go的GC采用的是并发的三色标记清除 (Concurrent Tri-color Mark-and-Sweep) 算法。

核心思想可以概括为：

1. 根对象 (Roots): 从程序的全局变量、Goroutine栈上的指针等根对象开始追踪。
2. 三色标记:

• 白色: 初始时所有对象都是白色，表示尚未被访问。GC结束后，仍为白色的对象将被回收。
• 灰色: 对象已被访问，但其引用的其他对象尚未完全扫描。灰色对象是待处理的。
• 黑色: 对象已被访问，并且其引用的所有对象都已被扫描或标记为灰色。黑色对象是存活的。

3. 标记阶段 (Marking):

• GC开始时，所有对象标记为白色。
• 从根对象开始，将其标记为灰色并放入待扫描队列。
• 不断从队列中取出灰色对象，将其标记为黑色，并将其引用的白色对象标记为灰色放入队列。
• 这个标记过程是并发的，意味着应用程序的Goroutine可以和GC的标记线程同时运行，从而大大减少STW (Stop-The-World，即cpu完全用来执行垃圾回收，而不执行代码，这样会造成程序的卡顿) 的时间。

4. 混合写屏障 (Hybrid Write Barrier，融合了插入写屏障和删除写屏障的思想):

• GC 开始将栈上的可达对象全部扫描并标记为黑色 (之后不再进行第二次重复扫描，无需 STW)，

• GC 期间，任何在栈上创建的新对象，均为黑色。（混合写屏障加入了这两条对栈区的操作，使得不需要STW）

• 被删除的对象标记为灰色。（删除写屏障）

• 被添加的对象标记为灰色。（插入写屏障）

补充： 插入写屏障：只应用于堆区，如果一个对象在并发过程中创建了一个新的对象，那么新的对象直接标记为灰色。
删除写屏障：如果一个对象在并发过程中被删除，那么直接标记该删除的对象为灰色。

6. 清除阶段 (Sweeping): 标记阶段完成后，所有仍然是白色的对象就是不可达的垃圾对象。清除阶段会回收这些白色对象的内存空间。这个阶段也可以部分并发执行。

3.闭包

实现闭包的一个重要前提就是函数是一等公民，它可以向其它类型的参数一样被传递。如果我们有一个函数，并且在这个函数里面又定义了另一个函数，且这个内部函数可以使用外部函数里面定义的变量，这就是闭包。当我们声明一个匿名函数时，他天生就是一个闭包。

4.go语言函数是一等公民是什么意思

函数是一等公民，意味着可以把函数赋值给变量或存储在数据结构中，也可以把函数作为其它函数的参数或者返回值。

5.sync.Mutex和sync.RWMutex

Mutex 也称为互斥锁，互斥锁就是互相排斥的锁，它可以用作保护临界区的共享资源，保证同一时刻只有一个 goroutine 操作临界区中的共享资源。互斥锁 Mutex类型有两个方法，Lock和 Unlock。

type Mutex struct {state int32 // 互斥锁的状态sema  uint32 // 信号量，用于控制互斥锁的状态
}

使用互斥锁的注意事项

• Mutex 类型变量的零值是一个未锁定状态的互斥锁
• Mutex 在首次被使用之后就不能再被拷贝（Mutex 是值类型，拷贝会同时拷贝互斥锁的状态）
• Mutex 在未锁定状态（还未锁定或已被解锁），调用 Unlock方法，将会引发运行时错误
• Mutex 的锁定状态与特定 goroutine 没有关联，Mutex 被一个 goroutine 锁定， 可以被另外一个 goroutine 解锁。（不建议使用，必须使用时需要格外小心）
• Mutex 的 Lock方法和 Unlock方法要成对使用，不要忘记将锁定的互斥锁解锁，一般做法是使用 defer

RWMutex 也称为读写互斥锁，读写互斥锁就是读取/写入互相排斥的锁。它可以由任意数量的读取操作的 goroutine 或单个写入操作的 goroutine 持有。读写互斥锁 RWMutex 类型有五个方法，Lock，Unlock，Rlock，RUnlock 和 RLocker。其中，RLocker 返回一个 Locker 接口，该接口通过调用rw.RLock 和 rw.RUnlock 来实现 Lock 和 Unlock 方法。

type RWMutex struct {w           Mutex        // held if there are pending writerswriterSem   uint32       // semaphore for writers to wait for completing readersreaderSem   uint32       // semaphore for readers to wait for completing writersreaderCount atomic.Int32 // number of pending readersreaderWait  atomic.Int32 // number of departing readers
}

使用读写互斥锁的注意事项

• RWMutex 类型变量的零值是一个未锁定状态的互斥锁
• RWMutex 在首次被使用之后就不能再被拷贝
• RWMutex 的读锁或写锁在未锁定状态，解锁操作都会引发 panic
• RWMutex 的一个写锁 Lock 去锁定临界区的共享资源，如果临界区的共享资源已被（读锁或写锁）锁定，这个写锁操作的 goroutine 将被阻塞直到解锁
• RWMutex 的读锁不要用于递归调用，比较容易产生死锁
• RWMutex 的锁定状态与特定的 goroutine 没有关联。一个 goroutine 可以 RLock（Lock），另一个 goroutine 可以 RUnlock（Unlock）
• 写锁被解锁后，所有因操作锁定读锁而被阻塞的 goroutine 会被唤醒，并都可以成功锁定读锁
• 读锁被解锁后，在没有被其他读锁锁定的前提下，所有因操作锁定写锁而被阻塞的 goroutine，其中等待时间最长的一个 goroutine 会被唤醒

Mutex 和 RWMutex 的区别

• RWMutex 将对临界区的共享资源的读写操作做了区分，RWMutex 可以针对读写操作做不同级别的锁保护。
• RWMutex 读写锁中包含读锁和写锁，它的 Lock和 Unlock 方法用作写锁保护，它的 Rlock和 RUnlock 方法用作读锁保护。
• RWMutex 读写锁中的读锁和写锁关系如下：
• 在写锁处于锁定状态时，操作锁定读锁的 goroutine 会被阻塞。
• 在写锁处于锁定状态时，操作锁定写锁的 goroutine 会被阻塞。
• 在读锁处于锁定状态时，操作锁定写锁的 goroutine 会被阻塞。
• 但是，在读锁处于锁定状态时，操作锁定读锁的 goroutine 不会被阻塞。我们可以理解为读锁保护的临界区的共享资源，多个读操作可以同时执行

6.sync.WaitGroup

sync.WaitGroup 用于阻塞等待一组 Go 程的结束。如果有一个任务可以分解成多个子任务进行处理，同时每个子任务没有先后执行顺序的限制，等到全部子任务执行完毕后，再进行下一步处理。这时每个子任务的执行可以并发处理，这种情景下适合使用sync.WaitGroup。

标准用法

• 启动 Go 程时调用 Add()
• 在 Go 程结束时调用 Done()
• 最后调用 Wait()

package main
import ("fmt""sync"
)
func main() {var wg sync.WaitGroupwg.Add(3)go handlerTask1(&wg)go handlerTask2(&wg)go handlerTask3(&wg)wg.Wait()fmt.Println("全部任务执行完毕.")
}
func handlerTask1(wg *sync.WaitGroup) {defer wg.Done()fmt.Println("执行任务 1")
}
func handlerTask2(wg *sync.WaitGroup) {defer wg.Done()fmt.Println("执行任务 2")
}
func handlerTask3(wg *sync.WaitGroup) {defer wg.Done()fmt.Println("执行任务 3")
}

7.sync.Cond

sync.Cond 条件变量用来协调想要访问共享资源的那些 goroutine，当共享资源的状态发生变化的时候，它可以用来通知被互斥锁阻塞的 goroutine。假设一个场景：有一个协程在异步地接收数据，剩下的多个协程必须等待这个协程接收完数据，才能读取到正确的数据。在这种情况下，如果单纯使用 chan 或互斥锁，那么只能有一个协程可以等待，并读取到数据，没办法通知其他的协程也读取数据。这个时候，就需要有个全局的变量来标志第一个协程数据是否接受完毕，剩下的协程，反复检查该变量的值，直到满足要求。或者创建多个 channel，每个协程阻塞在一个 channel 上，由接收数据的协程在数据接收完毕后，逐个通知。总之，需要额外的复杂度来完成这件事。Go 语言在标准库 sync 中内置一个sync.Cond 用来解决这类问题。和sync.Cond相关的有4个方法：

• NewCond创建实例
• Broadcast广播唤醒所有
• Signal唤醒一个协程
• Wait等待

package main
import ("log""sync""time"
)
var done bool
func main() {// 1. 定义一个互斥锁，用于保护共享数据mu := sync.Mutex{}// 2. 创建一个sync.Cond对象，关联这个互斥锁cond := sync.NewCond(&mu)go read("reader1", cond)go read("reader2", cond)go read("reader3", cond)write("writer", cond)time.Sleep(time.Second * 3)
}
func read(name string, c *sync.Cond) {// 3. 在需要等待条件变量的地方，获取这个互斥锁，并使用Wait方法等待条件变量被通知；c.L.Lock()for !done {c.Wait()}log.Println(name, "starts reading")c.L.Unlock()
}
func write(name string, c *sync.Cond) {// 4. 在需要通知等待的协程时，使用Signal或Broadcast方法通知等待的协程。log.Println(name, "starts writing")time.Sleep(time.Second)c.L.Lock()done = truec.L.Unlock()log.Println(name, "wakes all")c.Broadcast() // 如果不广播, read()方法的 log.Println(name, "starts reading")不会执行
}
/*
输出:2024/10/02 21:27:50 writer starts writing2024/10/02 21:27:51 writer wakes all2024/10/02 21:27:51 reader3 starts reading2024/10/02 21:27:51 reader1 starts reading2024/10/02 21:27:51 reader2 starts reading
*/

8.sync.Pool

sync.pool用于保存和复用临时对象，减少内存分配，降低 GC 压力。使用方式:

• 声明对象池
• Get & Put

package main
import ("encoding/json""fmt""sync"
)
type Student struct {Name string `json:"name"`
}
var studentPool = sync.Pool{New: func() interface{} {return new(Student)},
}
func main() {buf := `{"name":"Mike"}`stu := studentPool.Get().(*Student)fmt.Println(*stu) // {}err := json.Unmarshal([]byte(buf), stu)if err != nil {fmt.Printf("err:%s,err")return}fmt.Println(*stu)studentPool.Put(stu) // {Mike}stu2 := studentPool.Get().(*Student)fmt.Println(*stu2) // {Mike}
}

9.panic和recover

在Go语言中，panic和recover构成了处理程序运行时错误的两个基本机制。它们用于在出现严重错误时，能够优雅地终止程序或恢复程序的执行。

• panic机制
  panic是一个内建函数，用于在程序运行时抛出一个错误。当panic被调用时，当前的函数会立即停止执行，并开始逐层向上"冒泡"，直到被recover捕获或到达程序的顶层，导致程序崩溃并输出错误信息。

panic通常用于处理那些无法恢复的错误，比如空指针引用、数组越界等。这些错误如果不加以处理，将会导致程序崩溃。

• recover机制
  recover是一个内建函数，用于在defer函数中捕获由panic抛出的错误。当panic发生时，程序会立即停止当前函数的执行，并开始逐层向上查找是否有defer语句。如果在defer函数中调用了recover，那么panic会被捕获，程序会恢复正常的执行流程，继续执行defer函数之后的代码。

需要注意的是，recover只有在defer函数中直接调用时才有效。在其他地方调用recover是无效的，它将返回nil并且不会终止panic。

10.goroutine

在Go语言中，goroutine（Go routine）是一种轻量级的执行单元。可以将其理解为一个函数的并发执行，类似于线程，但比线程更轻量级。与传统的线程相比，创建和销毁goroutine的开销非常小。在Go程序中，可以轻松地创建成千上万个goroutine，每个goroutine都能够独立执行，而不需要手动管理线程和锁。这使得在Go语言中实现并发变得非常容易。要创建一个goroutine，只需要在函数调用前加上关键字"go"即可。Go语言的运行时系统（runtime）负责调度和管理goroutine的执行。运行时系统在多个逻辑处理器上调度goroutine，使得它们可以并发执行。以下是goroutine的底层实现原理的一些关键点：

• 栈的动态增长：每个goroutine有一个固定大小的栈空间，初始大小一般很小（几KB）。当需要更多的栈空间时，运行时系统会动态地扩展 栈的大小。这种栈的动态增长使得goroutine可以有效地处理深度递归或者大型数据结构。
• 上下文切换：当一个goroutine遇到阻塞操作（如等待I/O、等待通道的数据等）时，运行时系统会自动将该goroutine切换出执行，并让其他可运行的goroutine继续执行。这种上下文切换是协作式的，是在运行时系统控制下完成的，而不是由操作系统的调度器决定。这使得goroutine的切换非常高效。
• 调度器：Go语言的运行时系统有一个调度器（scheduler），负责在逻辑处理器上调度和管理goroutine的执行。调度器会根据一些策略（如工作窃取）来决定将goroutine分配给哪个逻辑处理器执行。调度器还会处理阻塞的goroutine，并在其可以继续执行时将其重新调度。
• 垃圾回收：运行时系统中的垃圾回收器（garbage collector）负责自动管理内存的分配和回收。垃圾回收器会追踪和收集不再使用的对象，并回收其占用的内存空间。垃圾回收器与goroutine的协作非常紧密，确保在回收内存时不会影响正在执行的goroutine。
• 同步和通信：在多个goroutine之间进行同步和通信通常使用通道（channel）。通道提供了一种安全可靠的方式来传递数据和同步操作。通道的使用能够确保在goroutine之间的数据传递和同步操作的正确性和可靠性。