How to print N integers using odd and even thread

I am trying to print N numbers from 2 go routines:

go routine odd(): this can only print odd numbers

go routine even(): this can only print even numbers

The output should be: 1 2 3 4 5 6 7 8 9 10

I am trying to solve this problem using sync.WaitGroup. I have following queries:

Q1. Which concurrency mechanism best suited for this problem? channel, waitgroup, mutex, etc? It would be ideal if you could provide a working code for the same.

Q2. Why I am not able to print the sequence correctly through below code? I am doing something wrong which I am not able to rectify. please help in rectifying.

package main

import (
    "fmt"
    "sync"
)

var wg sync.WaitGroup
var wgO sync.WaitGroup
var wgE sync.WaitGroup

func even() {
    defer wg.Done()

    for i := 2; i <= 10; i += 2 {
	    wgE.Add(1)
	    wgO.Wait()
	    fmt.Println(i)
	    wgE.Done()
    }
}
func odd() {
    defer wg.Done()

    for i := 1; i <= 10; i += 2 {
	    wgO.Add(1)
	    fmt.Println(i)
	    wgO.Done()
	    wgE.Wait()
    }
}
func main() {
    wg.Add(2)
    go even()
    go odd()
    wg.Wait()
}

> Q1. Which concurrency mechanism best suited for this problem? channel, waitgroup, mutex, etc?

None. Your problem is the opposite of something to be done concurrently and no concurrency mechanism helps you.

> Q2. Why I am not able to print the sequence correctly through below code?

You want independent goroutines to run synchronised. So you have to break concurrency. Technically a channel-based ping pong between these two goroutines would work, actually rendering them unconcurrent. Your problem has no sensible "concurrent" solution and you are not going to learn something from a crippled solution where concurrency is forcefully destroyed.

Some improvement on @Vibhor-Dubey-InfiniteLearner's answer, as there is a deadlock in his answer

func odd(n int, syncChannel, done chan bool) {

	for i := 0; i < n; i++ {
		<-syncChannel

		if i%2 != 0 {
			fmt.Println(i)
		}

		syncChannel <- true
	}
	done <- true
}

func even(n int, syncChannel, done chan bool) {

	for i := 0; i < n; i++ {
		<-syncChannel

		if i%2 == 0 {
			fmt.Println(i)
		}

		syncChannel <- true
	}

	done <- true
}

func main() {
	done := make(chan bool)
	syncChannel := make(chan bool)
	n := 10

	go even(n, syncChannel, done)
	syncChannel <- true // This will ensure, we start at even number
	go odd(n, syncChannel, done)

	<-done
	close(syncChannel)
}

Q1: Which concurrency mechanism best suited for this problem?

A1: None. Your problem of printing sequential numbers is not a concurrent one. So even if you implemented a solution that uses Go's concurrent mechanisms (either with channels or mutexs), it wouldn't/couldn't actually run concurrently, since what you want is sequentially printing your numbers. Running concurrently would print numbers is a non-deterministic order.

Q2: Why I am not able to print the sequence correctly through below code?

A2: Your code prints out of order because once go routines have been triggered, you have no way of knowing the order in which they are executed. So the code:

...
go even()
go odd()
...

doesn't even guarantee that the loop inside your even function will start before the loop inside your odd function, even thou the even function is called before.

A2.1: Your code can panic sometimes WaitGroup is reused before previous Wait has returned, because it's possible for wgO.Done() inside odd function to be called before wgO.Wait() is called inside the even function.

The following is a very silly implementation using sync.WaitGroup that works, and illustrates how the solution to your problem has to break concurrency to work. In order to print the numbers in order, I have to wait the completion of each go routine...

func main() {
	var wg sync.WaitGroup
	
	for i := 0; i <= 10; i++ {
		if i%2 == 0 {
			wg.Add(1)
			go func(i int) {
				defer wg.Done()
				fmt.Println(i)
			}(i)
			wg.Wait()
		} else {
			wg.Add(1)
			go func(i int) {
				defer wg.Done()
				fmt.Println(i)
			}(i)
			wg.Wait()
		}
	}
}

I wouldn't get too caught up in this problem as it's not a good example for leaning Go's concurrency mechanism.

There is a great course on cooursera for learning Go's concurrency here

package main

import (
	"fmt"
	"sync"
	"sync/atomic"
)

func main() {
	var done int32
	syncChannel := make(chan bool) // unbuffered channel.

	wg := new(sync.WaitGroup)
	wg.Add(2)

	go func() {
		// prints even numbers.
		defer wg.Done()

		for i := 0; i < 50; i += 2 {
			<-syncChannel

			fmt.Printf("Even: %d\n", i)

			syncChannel <- true
		}
		atomic.StoreInt32(&done, 1)
	}()

	syncChannel <- true

	go func() {
		// prints odd numbers.
		defer wg.Done()

		for i := 1; i < 50; i += 2 {
			<-syncChannel

			fmt.Printf("Odd:%d\n", i)

			if atomic.LoadInt32(&done) != 0 {
				return
			}

			syncChannel <- true
		}
	}()

	wg.Wait()
	close(syncChannel)
}

Reference: https://ayada.dev/snippets/ordered-printing-with-goroutines-in-go/