面试题：Go中Goroutine调度与性能优化的关系

高并发场景下Goroutine调度可能带来的性能问题

资源竞争：多个Goroutine可能同时访问共享资源，导致数据竞争和不一致问题，影响程序正确性与性能。例如多个Goroutine同时修改一个全局变量。
调度开销：频繁的Goroutine调度切换会带来额外的CPU开销，降低系统整体性能。因为调度时需要保存和恢复上下文环境。
死锁：当Goroutine之间通过通道（channel）或其他同步机制进行通信和同步时，可能出现死锁情况，导致程序挂起无法继续执行。例如两个Goroutine互相等待对方发送数据。
内存占用：大量Goroutine的创建可能导致内存占用过高，因为每个Goroutine都需要一定的栈空间，且调度器管理这些Goroutine也需要额外内存。

通过调度器参数调整提升性能

GOMAXPROCS参数：该参数设置了同时运行的最大CPU核数。通过合理设置可以充分利用多核CPU的性能。例如在多核服务器上，设置runtime.GOMAXPROCS(runtime.NumCPU())，可以让程序充分利用所有CPU核心，提升并行处理能力。若设置过小，无法充分利用多核；设置过大，可能导致调度开销增加。

通过代码层面优化提升性能

减少共享资源访问：尽量避免多个Goroutine同时访问共享资源。如果必须访问，使用sync.Mutex、sync.RWMutex等同步机制保护。例如：

package main

import (
    "fmt"
    "sync"
)

var (
    counter int
    mu      sync.Mutex
)

func increment(wg *sync.WaitGroup) {
    defer wg.Done()
    mu.Lock()
    counter++
    mu.Unlock()
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go increment(&wg)
    }
    wg.Wait()
    fmt.Println("Final counter:", counter)
}

优化通道使用：合理使用通道进行Goroutine间通信，避免无缓冲通道导致的阻塞。例如使用有缓冲通道来减少不必要的等待：

package main

import (
    "fmt"
)

func producer(ch chan int) {
    for i := 0; i < 10; i++ {
        ch <- i
    }
    close(ch)
}

func consumer(ch chan int) {
    for num := range ch {
        fmt.Println("Consumed:", num)
    }
}

func main() {
    ch := make(chan int, 5)
    go producer(ch)
    go consumer(ch)
    select {}
}

复用Goroutine：通过使用worker pool模式复用Goroutine，减少Goroutine创建和销毁的开销。例如：

package main

import (
    "fmt"
    "sync"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("Worker %d started job %d\n", id, j)
        result := j * j
        fmt.Printf("Worker %d finished job %d, result: %d\n", id, j, result)
        results <- result
    }
}

func main() {
    const numJobs = 5
    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    const numWorkers = 3
    var wg sync.WaitGroup
    for w := 1; w <= numWorkers; w++ {
        wg.Add(1)
        go func(id int) {
            defer wg.Done()
            worker(id, jobs, results)
        }(w)
    }

    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    go func() {
        wg.Wait()
        close(results)
    }()

    for r := range results {
        fmt.Println("Result:", r)
    }
}

面试题：Go中Goroutine调度与性能优化的关系

知识考点

面试题答案

高并发场景下Goroutine调度可能带来的性能问题

通过调度器参数调整提升性能

通过代码层面优化提升性能