Why am I getting all goroutines are asleep when I close the channel after waiting?

Following is the code:

func makeData() map[string][]Data {
m := make(map[string][]Data)
s := "abcdefghijklmno"
for i, c := range s {
data := []Data{
{value: "hey_" + string(c), id: i * i},
{value: "hello_" + string(c) + string(c), id: i + i},
{value: "bye_" + string(c), id: i + 1},
}
m[strconv.Itoa(i)] = data
}
return m
}
func process(key string, value []Data) (*Result, error) {
if key == "hey_a" {
return nil, errors.New("error")
}
res := Result{data: Data{value: "hi", id: 0}, id: 1}
return &res, nil
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
m := makeData()
errg := new(errgroup.Group)
mapChan := make(chan StringAndData)
sliceChan := make(chan *Result)
for key, value := range m {
key := key
value := value
errg.Go(func() error {
return func(key string, value []Data) error {
res, err := process(key, value)
if err != nil {
return err
}
if res == nil {
return nil
}
if res.data.id == 1 {
mapChan <- StringAndData{
str:  key,
data: res.data,
}
return nil
}
sliceChan <- res
return nil
}(key, value)
})
}
if err := errg.Wait(); err != nil {
fmt.Println("error")
} else {
fmt.Println("success")
}
close(mapChan)
close(sliceChan)
for ac := range mapChan {
fmt.Println(ac.str)
}
}
type Data struct {
value string
id    int
}
type Result struct {
data Data
id   int
}
type StringAndData struct {
str  string
data Data
}

Playground

I am getting fatal error: all goroutines are asleep - deadlock! but I am closing the channels after errg.Wait() and am not able to understand the reason.

I am trying to print values that I get from the channel after closing them using range.

I am new to channels and concurrency with go and would appreciate any help!

Edit
Added all the code from the playground link

Looking at your code, two things can cause a deadlock:

• errg.Wait() blocks the execution of the main goroutine until all initialized goroutines are finished. However, each goroutine is blocked when trying to write to mapChan, because you never get to read from it (because it is below the errg.Wait()).
• You never read from sliceChan, so that is a potential deadlock right there.

Here is the link to the modified Playground code, but most of the changes are in the main function.

func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
m := makeData()
errg := new(errgroup.Group)
mapChan := make(chan StringAndData)
sliceChan := make(chan *Result)
mapDone := make(chan bool)
sliceDone := make(chan bool)
go func(){
for ac := range mapChan {
fmt.Println(ac.str)
}
mapDone <- true
}()
go func(){
for ac := range sliceChan {
fmt.Println(ac)
}
sliceDone <- true
}()
for key, value := range m {
key := key
value := value
errg.Go(func() error {
return func(key string, value []Data) error {
res, err := process(key, value)
if err != nil {
return err
}
if res == nil {
return nil
}
if res.data.id == 1 {
mapChan <- StringAndData{
str:  key,
data: res.data,
}
return nil
}
sliceChan <- res
return nil
}(key, value)
})
}
if err := errg.Wait(); err != nil {
fmt.Println("error")
} else {
fmt.Println("success")
}
close(mapChan)
close(sliceChan)
<-mapDone
<-sliceDone
fmt.Println("finished")
}

Basically, I changed how the values are read from mapChan and sliceChan channels. This is done in separate goroutines, so reading from these channels is not blocked.

The mapDone and sliceDone channels are added just to make sure all of the data is read before the main goroutine finishes.