Runtime: goroutine blocks forever

I have this bit of Golang code here

package main

import (
	"fmt"
	"time"
)

func main() {
	burstyLimiter := make(chan time.Time, 3)
	for i := 1; i <= 3; i++ {
		burstyLimiter <- time.Now()
	}

	go func() {
		for t := range time.Tick(200 * time.Millisecond) {
			burstyLimiter <- t
		}
	}()

	burstyRequests := make(chan int, 5)
	for i := 1; i <= 5; i++ {
		burstyRequests <- i
	}
	for r := range burstyRequests {
		fmt.Println("received request", r, time.Now())
	}
}

When I run this, it blocks forever as shown here

Then I have another slightly modified version here

package main

import (
	"fmt"
	"time"
)

func main() {

	burstyRequests := make(chan int, 5)
	for i := 1; i <= 5; i++ {
		burstyRequests <- i
	}
	for r := range burstyRequests {
		fmt.Println("received request", r, time.Now())
	}
}

this version runs into a deadlock as expected as seen here

For the one which blocks forever, my assumption is due to the behavior of time.Tick which possibly results in a leak and the range over a channel which blocks as long as there’s a possibility of a write into the channel.

I would like to get help with clarity as to whether or not my understanding of this situation is correct.​​

Your primary issue is that you've setup a for-loop designed to pull data out of a channel, so long as it's open, without ever closing that channel. In the former case, the code blocks forever, likely because it's waiting on data to be pulled from burstyLimiter, which is write-deadlocked. In the latter case, the deadlock is simple enough for Go to detect it and it panics for you. To fix this, you need to do two things:

1. Ensure that the channel is closed
2. Ensure that the loop has a way to exit

Here's some code that should help you accomplish both of these:

package main

import (
    "fmt"
    "time"
)

func main() {

    burstyRequests := make(chan int, 5)
    for i := 1; i <= 5; i++ {
        burstyRequests <- i
    }

    defer close(burstyRequests)
loop:
    for {
        select {
            case r := <-burstyRequests:
                fmt.Println("received request", r, time.Now())
            default:
                break loop
        }
    }
}

This code works by first ensuring that burstyLimiter is closed when the function returns and then entering a loop wherein it attempts to receive from burstyLimiter until no more data can be received. This is the most basic way to do what you want.

If you have a more complex use-case, you could include another channel called quit that you send to when you want to stop receiving and then check if you receive on that or wait for data otherwise. Or you could add a timer. But, no matter what you do, you need a way to ensure that your program knows when it is done with its work and can shut down.