当前位置：首页 > article >正文

每日八股文6.2

article 2025/6/4 10:35:43

每日八股-6.2

Go
- 1.GMP调度原理（这部分多去看看golang三关加深理解）
- 2.GC（同样多去看看golang三关加深理解）
- 3.闭包
- 4.go语言函数是一等公民是什么意思
- 5.sync.Mutex和sync.RWMutex
- 6.sync.WaitGroup
- 7.sync.Cond
- 8.sync.Pool
- 9.panic和recover
- 10.goroutine

Go

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

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

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

调度流程可以概括为：

每个P会维护一个可运行的G队列 (Local Run Queue, LRQ)。
M需要获取一个P才能执行G。M会从其绑定的P的LRQ中获取G并执行。
如果P的LRQ为空，M会尝试从全局G队列 (Global Run Queue, GRQ)或其他P的LRQ中窃取 (Work Stealing) G来执行，以实现负载均衡。
当G执行系统调用或发生阻塞时，它所占用的M会和P解绑（Hand Off），P会去寻找其他空闲的M，或者创建一个新的M来继续执行队列中的其他G。阻塞的G结束后会尝试重新进入某个P的队列等待执行。
通过这种方式，GMP模型实现了高效的用户态调度，避免了频繁的内核态线程切换，并能充分利用多核CPU资源。

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

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

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

核心思想可以概括为：

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

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

标记阶段 (Marking):

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

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

GC 开始将栈上的可达对象全部扫描并标记为黑色 (之后不再进行第二次重复扫描，无需 STW)，
GC 期间，任何在栈上创建的新对象，均为黑色。（混合写屏障加入了这两条对栈区的操作，使得不需要STW）
被删除的对象标记为灰色。（删除写屏障）
被添加的对象标记为灰色。（插入写屏障）

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

清除阶段 (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之间的数据传递和同步操作的正确性和可靠性。