Why does sending to channel is blocked when a panic occurs?

I am going to show a simple compilable code snipped where I get weird behaviour: after I intentionally cause a panic in processData (because I pass nil-pointer) the sending to channel l.done is blocked!

package main

import (
	"context"
	"fmt"
	"time"
)

type Loop struct {
	done chan struct{}
}

type Result struct {
	ID string
}

func NewLoop() *Loop {
	return &Loop{
		done: make(chan struct{}),
	}
}

func (l *Loop) StartAsync(ctx context.Context) {
	go func() {
		defer func() {
			l.done <- struct{}{} // BLOCKED! But I allocated it in NewLoop ctor
			fmt.Sprintf("done")
		}()
		for {
			/**/
			var data *Result
			l.processData(ctx, data) // passed nil
		}
	}()
}

func (l *Loop) processData(ctx context.Context, data *Result) {
	_ = fmt.Sprintf("%s", data.ID) // intentional panic - OK
}
func main() {
	l := NewLoop()
	l.StartAsync(context.Background())
	time.Sleep(10 * time.Second)
}

I can recover() a panic before sending to channel and I get correct error message.
What does happen with channel? It it was closed, I would get panic on sending to closed channel

It's blocking because there isn't anything receiving from the channel. Both the receive & the send operations on an initialized and unbuffered channel will block indefinitely if the opposite operation is missing. I.e. a send to a channel will block until another goroutine receives from that channel, and, likewise, a receive from a channel will block until another goroutine sends to that channel.

So basically

done := new(chan struct{})
done<-struct{}{}

will block forever unless there is another goroutine that receives from the channel, i.e. <-done. That's how channels are supposed to behave. That's how the languages specification defines their behaviour.

about the possible fixes :

given the name of your channel, you may want to run close(l.done) rather than l.done <- struct{}{}.

• using a buffered channel and l.done <- struct{}{} on completion : only one call to <-l.done will be unblocked.

Suppose you have some code looking like :

l := NewLoop()

go func(){
    <-l.done
    closeLoggers()
}()

go func(){
    <-l.done
    closeDatabase()
}()

sending one item on the done channel will make that only one consumer will receive it, and in the above example only one of the two actions will be triggered when the loop completes.

• using close(l.done) : once a channel is closed all calls to receive from it will proceed.

In the above example, all actions will proceed.

As a side note: there is no need for a buffer if you use a channel only for its "open/closed" state.