GO program stuck in a loop

// _Closing_ a channel indicates that no more values
// will be sent on it. This can be useful to communicate
// completion to the channel's receivers.

package main

import "fmt"

// In this example we'll use a `jobs` channel to
// communicate work to be done from the `main()` goroutine
// to a worker goroutine. When we have no more jobs for
// the worker we'll `close` the `jobs` channel.
func main() {
	jobs := make(chan int, 5)
	done := make(chan bool)

	// Here's the worker goroutine. It repeatedly receives
	// from `jobs` with `j, more := <-jobs`. In this
	// special 2-value form of receive, the `more` value
	// will be `false` if `jobs` has been `close`d and all
	// values in the channel have already been received.
	// We use this to notify on `done` when we've worked
	// all our jobs.

	for i := 1; i <= 3; i++ {
		go func() {
			for {
				j, more := <-jobs
				if more {
					fmt.Println("received job", j)
				} else {
					fmt.Println("received all jobs")
					done <- true
					return
				}
			}
		}()
	}

	// This sends 3 jobs to the worker over the `jobs`
	// channel, then closes it.
	j := 0
	for {
		j++
		jobs <- j
		fmt.Println("sent job", j)
	}
	close(jobs)
	fmt.Println("sent all jobs")

	// We await the worker using the
	// [synchronization](channel-synchronization) approach
	// we saw earlier.
	<-done
}

https://play.golang.org/p/x28R_g8ftS

What I'm trying to do is get all the responses from a paginated url endpoint. jobs is a channel storing the page number. I have a function in if more{} checking for empty reponse and I have

done <- true
return

I thought this would close the go routine.
But, the page generator for{j++; jobs <- j} is causing it to get stuck in a loop. Any idea how this can be resolved?

By definition a for loop without conditions is an infinite loop. Unless you put some logic to break this infinite loop, you'll never get out of it.

In your playground your comment implies that you want to send 3 jobs. You should change your for loop accordingly:

for j := 0; j < 3; j++ {
  jobs <- j
  fmt.Println("sent job", j)
}

This is a simplified version of a worker.. Its not very useful for production level traffic, but should serve as a simple example, there are tons of them

package main

import (
	"log"
	"sync"
)

type worker struct {
	jobs chan int
	wg   *sync.WaitGroup
}

func main() {
	w := worker{
		jobs: make(chan int, 5), // I only want to work on 5 jobs at any given time
		wg:   new(sync.WaitGroup),
	}

	for i := 0; i < 3; i++ {
		w.wg.Add(1)
		go func(i int) {
			defer w.wg.Done()
			w.jobs <- i
		}(i)

	}

	// wait in the background so that i can move to line 34 and start consuming my job queue
	go func() {
		w.wg.Wait()
		close(w.jobs)
	}()

	for job := range w.jobs {
		log.Println("Got job, I should do something with it", job)
	}

}

This was I was looking for. I have a number generator in an infinite while loop. And the program exits on some condition, in this example, it is on the j value, but it can also be something else.

https://play.golang.org/p/Ud4etTjrmx

package main

import "fmt"



func jobs(job chan int) {
	i := 1
	for {
		job <- i
		i++
	}
}

func main() {
	jobsChan := make(chan int, 5)


	done := false
	j := 0

	go jobs(jobsChan)
	for !done {
		j = <-jobsChan
		if j < 20 {
			fmt.Printf("job %d\n", j)
		} else {
			done = true
		}
	}
}