Leaky Go Channels

package perform

import (
	"context"
	"math"
)

func Selecting(parent chan struct{}) {
	i := 0
	for {
		// Selecting within the infinite loop provides
		// control from the parent chan.
		// If the parent closes, we we can exit the loop and do any cleanup
		select {
		case <-parent:
			return
		default:
		}

		i++

		if i == math.MaxInt32 {
			// Simulate an error that exits the process loop
			break
		}
	}
}

func LeakyAsync(parent chan struct{}) {
	// Start a go routine to read and block off the parent chan.
	// If the parent chan closes, we can clean up within the go routine
	// without having to perform a "select" on each iteration
	// However, this go routine will never be garbage collected
	// if the parent chan does not close and any subsequent cleanup will
	// be left to leak
	go func(c <-chan struct{}) {
		<-c
	}(parent)

	i := 0
	for {
		i++

		if i == math.MaxInt32 {
			// Simulate an error that exits the process loop
			break
		}
	}
}

func ContextAsync(parentCtx context.Context) {
	// Generate a child context from a passed in parent context.
	// If the parent is closed or canceled,
	// the child will also be closed.
	// We can then safely start a go routine that will block on the
	// child's Done channel yet will still continue if the parent is canceled.
	ctx, cancel := context.WithCancel(parentCtx)
	defer cancel()

	go func(ctx context.Context) {
		<-ctx.Done()
	}(ctx)

	i := 0
	for {
		i++

		if i == math.MaxInt32 {
			// Simulate an error that exits the process loop
			break
		}
	}
}

package perform

import (
	"context"
	"testing"

	"github.com/fortytw2/leaktest"
)

func TestSelecting(t *testing.T) {
	leakChecker := leaktest.Check(t)

	c := make(chan struct{}, 1)
	Selecting(c)

	leakChecker()
	c <- struct{}{}
}

func BenchmarkSelecting(b *testing.B) {
	for n := 0; n < b.N; n++ {
		c := make(chan struct{})
		Selecting(c)
	}
}

func TestLeakyAsync(t *testing.T) {
	leakChecker := leaktest.Check(t)

	c := make(chan struct{}, 1)
	LeakyAsync(c)

	leakChecker()
	c <- struct{}{}
}

func BenchmarkLeakyAsync(b *testing.B) {
	for n := 0; n < b.N; n++ {
		c := make(chan struct{})
		LeakyAsync(c)
	}
}

func TestContextAsync(t *testing.T) {
	leakChecker := leaktest.Check(t)

	ctx, cancel := context.WithCancel(context.Background())
	ContextAsync(ctx)

	leakChecker()
	cancel()
}

func BenchmarkContextAsync(b *testing.B) {
	for n := 0; n < b.N; n++ {
		ctx, _ := context.WithCancel(context.Background())
		ContextAsync(ctx)
	}
}