Golang Even Odd print variable using sync.Cond

I am learning more about concurrency in Golang.
I am trying to print even-odd numbers using 2 different threads. I know printing even-odd more about synchronization/sequential access of shared resources than concurrency, still worth trying.

I know it can be done using channel or by using waitgroup and I have already done it but still trying to achieve same thing using sync.cond.

In the below code if I enable the last fmt.Println in both function then it print more than 10 number but if I comment it and enable first fmt.Print function then it works fine. Its very strange output.
I am not able to understand why this is happening can anyone let me know what i am doing wrong.

Thanks in advance.

package main

import (
	"fmt"
	"sync"
	"time"
)

var done bool

func odd(name *int, c *sync.Cond) {
	//fmt.Println(*name, "ODD ")
	if *name >= 9 {
		return
	}
	c.L.Lock()
	for !done {
		c.Wait()
	}
	*name++
	done = false
	fmt.Println(*name, "ODD")
	c.L.Unlock()
	c.Signal()
}

func even(name *int, c *sync.Cond) {

	//fmt.Println(*name, "EVEN ")
	if *name >= 9 {
		return
	}
	c.L.Lock()
	for done == true {
		c.Wait()
	}
	done = true
	*name++
	fmt.Println(*name, "EVEN ")
	c.L.Unlock()
	c.Signal()
}

func main() {
	done = false

	cond := sync.NewCond(&sync.Mutex{})
	val := 0
	for val < 10 {
		go odd(&val, cond)
		go even(&val, cond)
	}
	time.Sleep(10 * time.Second)
	fmt.Println("val final:=  ", val)
}

First output when last print enabled

1 EVEN <br/>
2 ODD<br/>
3 EVEN <br/>
4 ODD<br/>
5 EVEN <br/>
6 ODD<br/>
7 EVEN <br/>
8 ODD<br/>
9 EVEN <br/>
10 ODD<br/>
11 EVEN <br/>
12 ODD<br/>
13 EVEN <br/>
14 ODD<br/>
15 EVEN <br/>
16 ODD<br/>
17 EVEN <br/>
18 ODD<br/>
19 EVEN <br/>
20 ODD<br/>
21 EVEN <br/>
22 ODD<br/>
23 EVEN <br/>
24 ODD<br/>
25 EVEN <br/>
26 ODD<br/>
27 EVEN <br/>
28 ODD<br/>
29 EVEN <br/>
30 ODD<br/>
31 EVEN <br/>
32 ODD<br/>
33 EVEN <br/>
34 ODD<br/>
35 EVEN <br/>
36 ODD<br/>
37 EVEN <br/>
38 ODD<br/>
39 EVEN <br/>
40 ODD<br/>
41 EVEN <br/>
42 ODD<br/>
43 EVEN <br/>
44 ODD<br/>
45 EVEN <br/>
46 ODD <br/>
47 EVEN <br/>
48 ODD<br/>
49 EVEN <br/>
50 ODD<br/>
val final:= 51 <br/>

Output when First print enabled

0 EVEN<br/>
1 ODD <br/>
2 ODD <br/>
4 ODD <br/>
4 EVEN <br/>
2 ODD <br/>
2 EVEN <br/>
6 EVEN <br/>
10 ODD <br/>
2 ODD <br/>
2 EVEN <br/>
2 ODD <br/>
2 EVEN <br/>
10 ODD <br/>
2 EVEN <br/>
2 ODD <br/>
2 EVEN <br/>
2 EVEN <br/>
2 EVEN <br/>
2 ODD <br/>
2 EVEN <br/>
2 ODD <br/>
2 EVEN <br/>
2 ODD <br/>
2 EVEN <br/>
2 ODD <br/>
2 EVEN <br/>
2 ODD <br/>
2 EVEN <br/>
2 ODD <br/>
2 EVEN <br/>
2 ODD <br/>
2 EVEN <br/>
2 ODD <br/>
2 EVEN <br/>
2 ODD <br/>
2 EVEN <br/>
2 ODD <br/>
2 EVEN <br/>
2 ODD <br/>
2 ODD <br/>
2 ODD <br/>
2 EVEN <br/>
4 ODD <br/>
4 EVEN <br/>
4 ODD <br/>
4 EVEN <br/>
4 ODD <br/>
4 EVEN <br/>
4 ODD <br/>
4 EVEN <br/>
6 EVEN <br/>
6 ODD <br/>
6 EVEN <br/>
6 ODD <br/>
6 EVEN <br/>
8 EVEN <br/>
8 ODD <br/>
8 EVEN <br/>
10 EVEN <br/>
8 EVEN <br/>
10 EVEN <br/>
10 ODD <br/>
10 EVEN <br/>
2 ODD <br/>
10 EVEN <br/>
10 ODD <br/>
2 EVEN <br/>
10 EVEN <br/>
10 EVEN <br/>
val final:= 10 <br/>

Link for the Go playground: <br/>
https://go.dev/play/p/_Kcb_04JiPI

The most glaring issue is with the loop:

for val < 10 {
    go odd(&val, cond)
    go even(&val, cond)
}

I'm guessing your intent was to start two workers and wait for a termination event (val to reach 10).

Data-races aside, the above is a tight loop which will keep generating multiple (and unnecessary) "odd" and "even" goroutines while it waits for the termination event, creating unpredictable results.

You can see the the goroutine explosion by adding this line to the loop:

fmt.Println("goroutine #", runtime.NumGoroutine())

To fix, you need to start a single goroutine for both odd() and even() and use a "done" channel or context cancelation to signal the job is done to all goroutines. This then negates the need to poll val - which is a data-race since you are reading it while it is being updated in other goroutine(s) without any coordination on the "read" end.