How to execute multiple goroutines in parallel without a Deadlock

So I have been trying to run mutliple goroutines in parallel using a WaitGroup. Whatever I try I always end up with a "fatal error: all goroutines are asleep - deadlock!"

This is what my code looks like right now:

package main
import (
	"fmt"
	"sync"
	"time"
)
func main() {
	ch := make(chan time.Duration)
	var wg sync.WaitGroup
	for _, v := range []time.Duration{5, 1} {
		wg.Add(1)
		go func() {
			defer wg.Done()
			wait(v, ch)
		}()
	}
	wg.Wait()
}
func wait(seconds time.Duration, c chan time.Duration) {
	time.Sleep(seconds * time.Second)
	c <- seconds
}

However this results in a deadlock and I can't figure out why.

I have been trying to read the values after the WaitGroup with the following code:

	close(ch)
	for v := range ch {
		fmt.Println(v)
	}

However it seems it wouldn't even reach this part.

Thank you!

You need to close the worker channel after all the workers are done. You are closing it immediately from the main goroutine.

So do this:

go func() {
    wg.Wait()
    close(ch)
}()

Also your wait function already takes a time.Duration so really it should be in the real time at that point & not multiplied by time.Second. if you want to pass in units of seconds, consider changing the input type to int to avoid confusion.

There are two problems withe the code:

1. You must close the channel only after all go-routines have finished
2. The value of v is being lost during the iteration

In go, the for loop will reuse v, so all go-routines will have the same value on the wait call.

package main
import (
	"fmt"
	"sync"
	"time"
)
func main() {
	ch := make(chan time.Duration)
	var wg sync.WaitGroup
	for _, v := range []time.Duration{5, 1} {
		wg.Add(1)
		v := v // <- this
		go func() {
			defer wg.Done()
			wait(v, ch)
		}()
	}
	go func() { // Close the channel only after go-routines finish
		wg.Wait()
		close(ch)
	}()
	for v := range ch { // Will loop until channel is closed
		fmt.Println(v)
	}
}
func wait(seconds time.Duration, c chan time.Duration) {
	time.Sleep(seconds * time.Second)
	c <- seconds
}