What is an elegant way to shut down a chain of goroutines linked by channels?

I'm a Go learner. In order better to understand the care and feeding of channels and goroutines, I'm trying to build a Sieve of Eratosthenes as a set of goroutines connected into a pipeline by channels.

Here's what I have so far:

// esieve implements a Sieve of Eratosthenes
// as a series of channels connected together
// by goroutines
package main

import "fmt"

func sieve(mine int, inch chan int) {
	start := true                        // First-number switch
	ouch := make(chan int)               // Output channel for this instance
	fmt.Printf("%v\n", mine)             // Print this instance's prime
	for next := <-inch; next > 0; next = <-inch {  // Read input channel
		fmt.Printf("%v <- %v\n",mine,next)         // (Trace)
		if (next % mine) > 0 {                     // Divisible by my prime?
			if start {                   // No; is it the first number through? 
				go sieve(next, ouch)     // First number - create instance for it
				start = false            // First time done
			} else {                     // Not first time
				ouch <- next             // Pass it to the next instance
			}
		}
	}
}

func main() {
	lim := 30                     // Let's do up to 30
	fmt.Printf("%v\n", 2)         // Treat 2 as a special case
	ouch := make(chan int)        // Create the first segment of the pipe
	go sieve(3, ouch)             // Create the instance for '3'
	for prime := 3; prime < lim; prime += 2 { // Generate 3, 5, ...
		fmt.Printf("Send %v\n", prime)	      // Trace
		ouch <- prime                         // Send it down the pipe
	}
}

And as far as it goes, it works nicely.

However, when I finish the main loop, main exits before all the numbers still in the pipeline of sieve instances have propagated down to the end.

What is the simplest, most elegant, or generally accepted way to make a main routine wait for a set of goroutines (about which it only 'knows' of the first one) to complete?

As for your title question, killing worker goroutines when you don't need them anymore:
You could use the Done idiom. Reads from a closed channel yield the zero value.

Make a new channel done. When reads from this channel succeed, the goroutines know they should quit. Close the channel in main when you have all the values you need.

Check if you can read from a channel done, and exit by returning, or read from next when that's available. This partially replaces the assignment to next in you for loop:

select {
case <-done:
return
case next = <- inch:
}

Ranging over a channel also works, since closing that channel exits the loop.

As for the reverse, your body question, waiting for a set of goroutines to finish:

Use sync.WaitGroup.

var wg sync.WaitGroup
wg.Add(goroutineCount)

And when each goroutine finishes:

wg.Done()

Or use defer:

defer wg.Done()

To wait for all of them to report as Done:

wg.Wait()

In your example, simply call wg.Add(1) when you start a new goroutine, before you call wg.Done() and return. As long as you only reach zero once, wg.Wait() works as expected, so wg.Add(1) before wg.Done.

After @izca unblocked my logjam, and after a few false starts involving deadlocks when everything finished, here's my solution working correctly:

// esieve implements a Sieve of Eratosthenes
// as a series of channels connected together
// by goroutines
package main

import "fmt"

func sieve(mine int,                  // This instance's own prime
	       inch chan int,             // Input channel from lower primes
	       done chan int,             // Channel for signalling shutdown
	       count int) {               // Number of primes - counter
	start := true                     // First-number switch
	ouch := make(chan int)            // Output channel, this instance
	fmt.Printf("%v ", mine)           // Print this instance's prime
	for next := <-inch; next > 0; next = <-inch { // Read input channel
		if (next % mine) > 0 {        // Divisible by my prime?
			if start {                // No; first time through?
				go sieve(next, ouch, done, count+1) // First number,
				                                    // create instance for it
				start = false         // First time done
			} else {                  // Not first time
				ouch <- next          // Pass to next instance
			}
		}
	}
	if start {                        // Just starting?
		close(done)                   // Yes - we're last in pipe - signal done
		print("\n",count," primes\n") // Number of primes/goroutines
	} else {
		close(ouch)                   // No - send the signal down the pipe
	}
}

func main() {
	lim := 100                        // Let's do up to 100
	done := make(chan int)            // Create the done return channel
	ouch := make(chan int)            // Create the first segment of the pipe
	go sieve(2, ouch, done, 1)        // Create the first instance for '2'
	for prime := 3; prime < lim; prime += 1 { // Generate odd numbers
		ouch <- prime                         // Send numbers down the pipe
	}
	close(ouch)                       // Send the done signal down the pipe
	<- done                           // and wait for it to come back
}

I'm tremendously impressed with the elegance and simplicity of Go for this kind of programming, when compared with many other languages. Of course, the warts I claim for myself.

If appropriate here, I'd welcome critical comments.