The done Channel Pattern

func doWork(done <-chan interface{}) <-chan interface{} {
    terminated := make(chan interface{})
    go func() {
        defer close(terminated)
        for {
            select {
            case s := <-strings:
                // Do work
            case <-done:  // Parent says "stop working"
                return
            }
        }
    }()
    return terminated
}

Key insight: Pass a done channel to every goroutine so the parent can signal cancellation.

Preventing Goroutine Leaks

Without cancellation (bad):

newRandStream := func() <-chan int {
    randStream := make(chan int)
    go func() {
        for {
            randStream <- rand.Int()  // runs forever!
        }
    }()
    return randStream
}

With cancellation (good):

newRandStream := func(done <-chan interface{}) <-chan int {
    randStream := make(chan int)
    go func() {
        defer close(randStream)
        for {
            select {
            case randStream <- rand.Int():
            case <-done:
                return  // clean exit
            }
        }
    }()
    return randStream
}

for-select Loop Pattern

This pattern shows up everywhere in Go:

for {
    select {
    case <-done:
        return
    default:
        // do non-preemptable work
    }
}

Two variations:

With default: Non-blocking, checks done channel between work
Without default: Blocking, waits for channels

Preventing goroutine leaks

Comments

More from this blog

Become a cracked product engineer today

Bipedal, humanoid, and the words for creature shapes in games

Lerp and smoothstep, what they actually do

IK and FK, what they actually are

How to make your textures fast on the GPU

The done Channel Pattern

Preventing Goroutine Leaks

Without cancellation (bad):

With cancellation (good):

for-select Loop Pattern

Command Palette

Comments

More from this blog

The done Channel Pattern

Preventing Goroutine Leaks

Without cancellation (bad):

With cancellation (good):

for-select Loop Pattern