Killing a goroutine once theres a new value in a channel

For each new value in a channel, a goroutine spawns. When there's a new value in a channel, I want a new goroutine to start, and the old one to be killed. I suspect that my code is killing the new goroutine and keeping the first one alive. how can I fix this?

func Start() {
	go func() {
		quit := make(chan bool, 1)
		for nbp := range poll() {
			quit <- true
			go create(nbp, quit)
		}
	}()
}

func create(nbp map[string]string, , quit chan bool) {
	for {
		select {
		case <-quit:
			fmt.Println("quiting this goroutine!")
			return
		default:
			for k, v := range nbp {
			...
            }
			time.Sleep(3 * time.Second)
		}
	}
}

So looking at the code you provided, you're wanting to spin up a new routine every time poll provides new data. That's trivial to do:

func Start() {
    for nbp := range poll() {
        go create(nbp)
    }
}

func create(nbp map[string]string) {
    // do stuff here
}

OK, but with this approach, you might be spawning a ton of routines at the same time. The quit channel you're using suggests you only want to spawn a new routine after the previous one has finished. Again, this is trivial to achieve:

func Start() {
    ch := make(chan struct{}) // struct{} is 0 bytes in size as per spec
    defer close(ch) // close channel when done
    for nbp := range poll() {
        go create(nbp, ch)
        ch <- struct{}{} // blocks until the routine has read from the channel
    }
}

func create(nbp map[string]string, ch <-chan struct{}) {
    for k, v := range nbp {
        // ... do stuff
    }
    time.Sleep(3 * time.Second)
    <-ch // read to unblock Start
}

Great, but now we're just doing things in sequence, and using a pretty pointless channel to do so... Why not simply do this:

func Start() {
    ch := make(chan map[string]string) // data in the channel
    defer close(ch) // close channel when done
    go create(ch) // start the routine reading data from the channel
    for nbp := range poll() {
        ch <- nbp // put data on channel, blocks until routine reads from the channel
        time.Sleep(3 * time.Second) // sleep here
    }
}

func create(nbp <-chan map[string]string) {
    for nbp := range ch { // read from channel
        // and process sequentially
        for k, v := range nbp {
            // ... do stuff
        }
    }
}

The reason why I moved the sleep to the loop that writes to the channel is because on the first iteration, the routine will immediately read from the channel (it's not doing anything yet), and unblock the poll() loop. That'll result in 2 calls to poll() in quick succession. Moving the sleep out of the routine ensures that you'll have at least 3 seconds in between the first and second call. After that, the behaviour is pretty much identical. I say pretty much, because you're not "bothering" the runtime and scheduler as much in order to release resources associated with the create routine every time, and scheduling a new routine immediately after.

A simple workaround looks like this

package main

func Start() {
	go func() {
		var i int
		quit := make(chan bool)
		for nbp := range poll() {
			if i > 0 {
				quit <- true
			}
			i++
			go create(nbp, quit)
		}
	}()
}

func create(nbp map[string]string, quit chan bool) {
	for {
		select {
		case <-quit:
			fmt.Println("quiting this goroutine!")
			return
		default:
			for k, v := range nbp {
			//...
			}
			time.Sleep(3 * time.Second)
		}
	}
}