How to detect goroutine leaks?

Question

In the below code:

package main

import (
    "context"
    "fmt"
    "time"
)

func cancellation() {
    duration := 150 * time.Millisecond
    ctx, cancel := context.WithTimeout(context.Background(), duration)
    defer cancel()

    ch := make(chan string)

    go func() {
        time.Sleep(time.Duration(500) * time.Millisecond)
        ch <- "paper"
    }()

    select {
    case d := <-ch:
        fmt.Println("work complete", d)
    case <-ctx.Done():
        fmt.Println("work cancelled")
    }

    time.Sleep(time.Second)
    fmt.Println("--------------------------------------")
}

func main() {
    cancellation()
}

---

Because of unbuffered channel( ch := make(chan string) ), go-routine leaks due to block on send( ch <- "paper" ), if main goroutine is not ready to receive.

Using buffered channel ch := make(chan string, 1) does not block send( ch <- "paper" )

How to detect such go-routine leaks?

Answer 1

There are some packages that let you do that. Two that I've used in the past:

• https://github.com/fortytw2/leaktest
• https://github.com/uber-go/goleak

Generally, they use functionality from the runtime package to examine the stack before and after your code runs and report suspected leaks. It's recommended to use them in tests. I found this works well in practice and used it in a couple of projects.