面试题：Go语言中通道与Goroutine内存管理之Goroutine内存泄漏

可能导致Goroutine内存泄漏的场景：

无缓冲通道发送阻塞：当一个Goroutine向无缓冲通道发送数据，而没有其他Goroutine从该通道接收数据时，发送操作会永远阻塞，导致该Goroutine及其相关资源无法释放，造成内存泄漏。例如：

package main

import (
    "fmt"
)

func main() {
    ch := make(chan int)
    go func() {
        ch <- 1 // 这里会永远阻塞，因为没有接收者
    }()
    fmt.Println("main done")
}

有缓冲通道填满阻塞：有缓冲通道在填满数据后，如果继续向其发送数据，而没有及时接收，同样会导致发送Goroutine阻塞。例如：

package main

import (
    "fmt"
)

func main() {
    ch := make(chan int, 1)
    ch <- 1
    go func() {
        ch <- 2 // 这里会阻塞，因为通道已满且无接收者
    }()
    fmt.Println("main done")
}

未关闭的通道导致Goroutine泄漏：如果一个Goroutine从通道接收数据，但该通道永远不会关闭，当发送方Goroutine结束后，接收方Goroutine可能会一直阻塞，造成内存泄漏。例如：

package main

import (
    "fmt"
)

func producer(ch chan int) {
    for i := 0; i < 5; i++ {
        ch <- i
    }
    // 这里没有关闭通道
}

func consumer(ch chan int) {
    for {
        data, ok := <-ch
        if!ok {
            return
        }
        fmt.Println("Received:", data)
    }
}

func main() {
    ch := make(chan int)
    go producer(ch)
    go consumer(ch)
    // 主函数没有等待Goroutine完成的逻辑
    fmt.Println("main done")
}

Goroutine持有大对象引用：如果Goroutine内部持有对大对象的引用，而这些Goroutine没有被正确终止，即使不再使用这些大对象，它们也不会被垃圾回收，导致内存泄漏。例如：

package main

import (
    "fmt"
)

type BigObject struct {
    data [1000000]int
}

func memoryLeak() {
    bigObj := BigObject{}
    go func() {
        // 这里Goroutine一直运行，持有bigObj的引用，导致bigObj无法被回收
        for {
            fmt.Println("Running")
        }
    }()
}

func main() {
    memoryLeak()
    fmt.Println("main done")
}

代码优化避免内存泄漏的方法：

确保通道有接收者：在向无缓冲通道发送数据前，确保有对应的接收者。可以通过提前启动接收Goroutine或使用select语句处理多个通道操作，避免阻塞。例如：

package main

import (
    "fmt"
)

func main() {
    ch := make(chan int)
    go func() {
        data := <-ch
        fmt.Println("Received:", data)
    }()
    ch <- 1
    fmt.Println("main done")
}

合理控制通道缓冲区：对于有缓冲通道，要根据实际需求设置合适的缓冲区大小，并及时处理通道中的数据，避免通道填满阻塞。例如：

package main

import (
    "fmt"
)

func main() {
    ch := make(chan int, 1)
    ch <- 1
    go func() {
        data := <-ch
        fmt.Println("Received:", data)
    }()
    fmt.Println("main done")
}

及时关闭通道：当发送方完成数据发送后，要及时关闭通道，以便接收方可以检测到通道关闭并退出循环。例如：

package main

import (
    "fmt"
)

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

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

func main() {
    ch := make(chan int)
    go producer(ch)
    go consumer(ch)
    // 这里可以添加等待Goroutine完成的逻辑，如使用sync.WaitGroup
    fmt.Println("main done")
}

避免Goroutine持有不必要的大对象引用：在Goroutine完成任务后，及时释放对大对象的引用，以便垃圾回收器可以回收这些对象。例如：

package main

import (
    "fmt"
)

type BigObject struct {
    data [1000000]int
}

func noMemoryLeak() {
    bigObj := BigObject{}
    go func() {
        // 处理完逻辑后，将bigObj设为nil，释放引用
        defer func() {
            bigObj = BigObject{}
        }()
        // 处理bigObj的逻辑
        fmt.Println("Processed big object")
    }()
}

func main() {
    noMemoryLeak()
    fmt.Println("main done")
}

星途面试题库

面试题：Go语言中通道与Goroutine内存管理之Goroutine内存泄漏

知识考点

面试题答案

可能导致Goroutine内存泄漏的场景：

代码优化避免内存泄漏的方法：