How to use a dedicated channel to signal the end of a crawl job in go

This is a follow up from my previous question.

I am trying to build a prototype for a webcrawler and I want to use a chan to block the execution until all the jobs are done, just as in

func main() {
	go func() {
	    do_stuff()
	    stop <- true
   }
	fmt.Println(<-stop)
}

There is a queue function that dispatch the jobs to the workers. When all jobs are finished, the function will also the channel and send a signal.

type Job int

//simulating a worker that processes a html page and returns some more links
func worker(in chan Job, out chan Job, num int) {
	for element := range in {
		if element%2 == 0 {
			out <- 100*element + 5
			out <- 100*element + 3
			out <- 100*element + 1
		}
	}
}

func queue(toWorkers chan<- Job, fromWorkers <-chan Job, init Job, stop chan bool) {
	var list []Job
	var currentJobs int
	currentJobs = 0
	list = append(list, init)
	done := make(map[Job]bool)
	for {
		var send chan<- Job
		var item Job
		if len(list) > 0 {
			send = toWorkers
			item = list[0]
		} else if currentJobs == 0 {
			close(toWorkers)
			// this messes up everything!
			stop <- true
			return
		}

		select {
		case send <- item:
			currentJobs += 1
			// We sent an item, remove it
			list = list[1:]
		case thing := <-fromWorkers:
			currentJobs -= 1
			// Got a new thing
			if !done[thing] {
				list = append(list, thing)
				done[thing] = true
			}
		}
	}

}

func main() {
	in := make(chan Job, 1)
	out := make(chan Job, 1)
	stop := make(chan bool)
	// dispatches jobs to workers
	go queue(in, out, 0, stop)
	for i := 0; i < max_workers; i++ {
		go worker(in, out, i)
	}
	duration := time.Second
	time.Sleep(duration)
	// this cause deadlock
	fmt.Println(<-stop)
}

Link to playground

If I understand correctly, the problem is with the stop channel: when the workers still have jobs, go thinks that no one will send to that channel and declares deadlock. The function queue will both close the toWorkers channel and send a signal to stop, but not while there are outstanding jobs.
What am I missing?

Use sync.WaitGroup to wait for all the go routines to end.

http://golang.org/pkg/sync/#WaitGroup

http://blog.golang.org/pipelines

I made a small example here: http://play.golang.org/p/P30LdV0Gfe

package main

import (
	"fmt"
	"sync"
)

func main() {
	var wg sync.WaitGroup
	routinesNo := 10
	wg.Add(routinesNo)
	for i := 0; i < routinesNo; i++ {
		go func(n int) {
			fmt.Printf("%d ", n)
			wg.Done()
		}(i)
	}
	wg.Wait()
	fmt.Println("\nThe end!")
}