Golang goroutine with time

I am in the process of learning Golang and writing some sample programs to familiarize myself with different concepts.
I wrote this sample piece to see how the go routines work and ran into this issue.
I couldn't figure out what is wrong with this program. It works perfectly when the last line in generateOddRandomNumbers() and geneateEvenRandomNumbers() is commented out.

// time.Sleep(time.Duration(val))

The moment I uncomment that line in both the functions, the output is always wrong.

Code:

package main

import (
	"fmt"
	"math/rand"
	"time"
)

const (
	limit = 10000
)

func main() {
	rand.Seed(time.Now().UnixNano())
	go generateOddRandomNumbers(rand.Intn(9) + 1)
	go generateEvenRandomNumbers(rand.Intn(9) + 1)
	time.Sleep(1000000)
}

func generateOddRandomNumbers(count int) {
	for i := 0; i < count; i++ {
		val := rand.Intn(limit)
		if val % 2 == 0 {
			i--
			continue
		}
		fmt.Printf("Odd[%v/%v] -> %v\n", i + 1, count, val)
		// time.Sleep(time.Duration(val))
	}
}

func generateEvenRandomNumbers(count int) {
	for i := 0; i < count; i++ {
		val := rand.Intn(limit)
		if val % 2 != 0 {
			i--
			continue
		}
		fmt.Printf("Even[%v/%v] -> %v\n", i + 1, count, val)
		// time.Sleep(time.Duration(val))
	}
}

For example:
Good Output: Even() got printed from 1/6 to 6/6 and Odd() got printed 1/3 to 3/3

Even[1/6] -> 5202
Even[2/6] -> 2768
Even[3/6] -> 3020
Even[4/6] -> 6386
Even[5/6] -> 8004
Odd[1/3] -> 5075
Odd[2/3] -> 8057
Odd[3/3] -> 9655
Even[6/6] -> 8886

Bad Output: (when time.Sleep() is uncommented)
In the below case, Even got printed only from 1/9 to 3/9 (as opposed to 1/9 to 9/9)

Odd[1/1] -> 4349
Even[1/9] -> 6024
Even[2/9] -> 5444
Even[3/9] -> 6160

Any idea?

A Go program doesn’t wait for your go routines to finish.

• If you comment time.Sleep in goroutine, you goroutine run quickly, so you get a full output.

• If you uncomment time.Sleep in goroutine, you goroutine run slowly. Once it yield scheduler, the main go program finish, so your goroutine don't have chance to finish the whole run.

You may use channel or sync.WaitGroup to sync your procedure, like How to wait for all goroutines to finish in Golang.

BTW, for time.Sleep(1000000), its unit is ns, so main go program exit quickly in your example.

The reason why your program exits is because the main thread doesn't wait on spawned goroutines to finish. You have to keep the main thread open.

One way to do this is with WaitGroups.

Using a modified version of this example, you could do something like:

Go Playground

package main

import (
	"fmt"
	"math/rand"
	"sync"
	"time"
)

const (
    limit = 10000
)

func main() {
	rand.Seed(time.Now().UnixNano())
	
	var wg sync.WaitGroup
	// Add our two items to the wait group
	wg.Add(2)
	
	// Call our two items
	go generateOddRandomNumbers(rand.Intn(9) + 1, &wg)
	go generateEvenRandomNumbers(rand.Intn(9) + 1, &wg)

	// Wait for them
	wg.Wait()
}

func generateOddRandomNumbers(count int, wg *sync.WaitGroup) {
	defer wg.Done();
	for i := 0; i < count; i++ {
		val := rand.Intn(limit)
		if val%2 == 0 {
			i--
			continue
		}
		fmt.Printf("Odd[%v/%v] -> %v\n", i+1, count, val)
		// time.Sleep(time.Duration(val))
	}
}

func generateEvenRandomNumbers(count int, wg *sync.WaitGroup) {
	defer wg.Done();
	for i := 0; i < count; i++ {
		val := rand.Intn(limit)
		if val%2 != 0 {
			i--
			continue
		}
		fmt.Printf("Even[%v/%v] -> %v\n", i+1, count, val)
		// time.Sleep(time.Duration(val))
	}
}

/** Which outputs:
Even[1/8] -> 2162
Even[2/8] -> 324
Even[3/8] -> 8388
Even[4/8] -> 7084
Even[5/8] -> 9282
Even[6/8] -> 302
Even[7/8] -> 6232
Even[8/8] -> 8384
Odd[1/3] -> 5063
Odd[2/3] -> 1239
Odd[3/3] -> 7947
*/