golang源码分析：uber-go/goleak检查goroutine泄漏原理

package leak

func leak() {
  ch := make(chan struct{})
  go func() {
    ch <- struct{}{}
  }()
}

package leak

import (
  "testing"

  "go.uber.org/goleak"
)


func Test_leak(t *testing.T) {
  defer goleak.VerifyNone(t)
  tests := []struct {
    name string
  }{
    // TODO: Add test cases.
    {},
  }
  for _, tt := range tests {
    t.Run(tt.name, func(t *testing.T) {
      leak()
    })
  }
}

--- FAIL: Test_leak (0.45s)
    /Users/xiazemin/groutine/leak/leak_test.go:25: found unexpected goroutines:
        [Goroutine 22 in state chan send, with groutine/leak.leak.func1 on top of the stack:
        goroutine 22 [chan send]:
        groutine/leak.leak.func1()
          /Users/xiazemin/groutine/leak/leak.go:6 +0x2c
        created by groutine/leak.leak
          /Users/xiazemin/groutine/leak/leak.go:5 +0x6e
        ]
FAIL

package leak

import (
  "testing"

  "go.uber.org/goleak"
)

func TestMain(m *testing.M) {
  goleak.VerifyTestMain(m)
}

func Test_leakM(t *testing.T) {
  tests := []struct {
    name string
  }{
    // TODO: Add test cases.
    {},
  }
  for _, tt := range tests {
    t.Run(tt.name, func(t *testing.T) {
      leak()
    })
  }
}

goleak: Errors on successful test run: found unexpected goroutines:
[Goroutine 6 in state chan send, with groutine/leak.leak.func1 on top of the stack:
goroutine 6 [chan send]:
groutine/leak.leak.func1()
  /Users/xiazemin/groutine/leak/leak.go:6 +0x2c
created by groutine/leak.leak
  /Users/xiazemin/groutine/leak/leak.go:5 +0x6e
]

func VerifyTestMain(m TestingM, options ...Option) 
func VerifyNone(t TestingT, options ...Option)

opts := buildOpts(options...)

cleanup, opts.cleanup = opts.cleanup, nil

if err := Find(opts); err != nil {
  t.Error(err)
}
  
cleanup(0)

func buildOpts(options ...Option) *opts {
  opts := &opts{
    maxRetries: _defaultRetries,
    maxSleep:   100 * time.Millisecond,
  }
  opts.filters = append(opts.filters,
    isTestStack,
    isSyscallStack,
    isStdLibStack,
    isTraceStack,
  )
  for _, option := range options {
    option.apply(opts)
  }
  return opts
}

func isTestStack(s stack.Stack) bool {
  // Until go1.7, the main goroutine ran RunTests, which started
  // the test in a separate goroutine and waited for that test goroutine
  // to end by waiting on a channel.
  // Since go1.7, a separate goroutine is started to wait for signals.
  // T.Parallel is for parallel tests, which are blocked until all serial
  // tests have run with T.Parallel at the top of the stack.
  switch s.FirstFunction() {
  case "testing.RunTests", "testing.(*T).Run", "testing.(*T).Parallel":
    // In pre1.7 and post-1.7, background goroutines started by the testing
    // package are blocked waiting on a channel.
    return strings.HasPrefix(s.State(), "chan receive")
  }
  return false
}

func isSyscallStack(s stack.Stack) bool {
  // Typically runs in the background when code uses CGo:
  // https://github.com/golang/go/issues/16714
  return s.FirstFunction() == "runtime.goexit" && strings.HasPrefix(s.State(), "syscall")
}

func isStdLibStack(s stack.Stack) bool {
  // Importing os/signal starts a background goroutine.
  // The name of the function at the top has changed between versions.
  if f := s.FirstFunction(); f == "os/signal.signal_recv" || f == "os/signal.loop" {
    return true
  }

  // Using signal.Notify will start a runtime goroutine.
  return strings.Contains(s.Full(), "runtime.ensureSigM")
}

func isTraceStack(s stack.Stack) bool {
  return strings.Contains(s.Full(), "runtime.ReadTrace")
}

func Find(options ...Option) error {
  cur := stack.Current().ID()

  opts := buildOpts(options...)
  if opts.cleanup != nil {
    return errors.New("Cleanup can only be passed to VerifyNone or VerifyTestMain")
  }
  var stacks []stack.Stack
  retry := true
  for i := 0; retry; i++ {
    stacks = filterStacks(stack.All(), cur, opts)

    if len(stacks) == 0 {
      return nil
    }
    retry = opts.retry(i)
  }

  return fmt.Errorf("found unexpected goroutines:\n%s", stacks)
}

func Current() Stack {
  return getStacks(false)[0]
}

func getStacks(all bool) []Stack {
  stackReader := bufio.NewReader(bytes.NewReader(getStackBuffer(all)))
       line, err := stackReader.ReadString('\n')
       if strings.HasPrefix(line, "goroutine ") {
         id, goState := parseGoStackHeader(line)
            curStack = &Stack{
              id:        id,
              state:     goState,
              fullStack: &bytes.Buffer{},
            }
       
}

func getStackBuffer(all bool) []byte {
  for i := _defaultBufferSize; ; i *= 2 {
    buf := make([]byte, i)
    if n := runtime.Stack(buf, all); n < i {
      return buf[:n]
    }
  }
}

func parseGoStackHeader(line string) (goroutineID int, state string) {
  line = strings.TrimSuffix(line, ":\n")
  parts := strings.SplitN(line, " ", 3)
  if len(parts) != 3 {
    panic(fmt.Sprintf("unexpected stack header format: %q", line))
  }

  id, err := strconv.Atoi(parts[1])

func All() []Stack {
  return getStacks(true)
}

func filterStacks(stacks []stack.Stack, skipID int, opts *opts) []stack.Stack {
  filtered := stacks[:0]
  for _, stack := range stacks {
    // Always skip the running goroutine.
    if stack.ID() == skipID {
      continue
    }
    // Run any default or user-specified filters.
    if opts.filter(stack) {
      continue
    }
    filtered = append(filtered, stack)
  }
  return filtered
}