Not getting expected output from goroutine

I read it on (https://www.geeksforgeeks.org/channel-in-golang/) that:

"In the channel, the send and receive operation block until another side is not ready by default.
It allows goroutine to synchronize with each other without explicit locks or condition variables."

To test above statement, I have written a sample program mentioned below:

Program:

package main
import (
    "fmt"
    "sync"
    "time"
)

func myFunc(ch chan int) {
    fmt.Println("Inside goroutine:: myFunc()")
    fmt.Println(10 + <-ch) //<-- According to rule, control will be blocked here until 'ch' sends some data so that it will be received in our myFunc() go routine.
}
func main() {

    fmt.Println("Start Main method")
    // Creating a channel
    ch := make(chan int)

    go myFunc(ch) //<-- This go routine started in a new thread

    time.Sleep(2 * time.Second) //<--- introduced a Sleep of 2 seconds to ensure that myFunc() go routine executes before main thread
    ch <- 10
    fmt.Println("End Main method")
}

I was expecting below output:

Start Main method

Inside goroutine:: myFunc()

20

End Main method

But, Actual output received is:

Start Main method

Inside goroutine:: myFunc()

End Main method

Why the value sent through channel is not printed?
I think, it is because main thread finished its execution first and hence, all other goroutine also terminated.

If that is the case, then, why does the rule said - It allows goroutine to synchronize with each other without explicit locks or condition variables.

Because, to get the expected output, I have to use sync.WaitGroup to tell the main thread to wait for the other goroutine to finish. Isn't it violating the above rule as I am using locks in form of waitgroup?

PS: I am learning golang. So please forgive if I get the concept totally wrong.

The main goroutine exists before the myFunc goroutine is able to print the output. Here is an implementation which ensures that myFunc goroutine finishes before the main goroutine exits.

package main

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

func myFunc(ch chan int, wg *sync.WaitGroup) {
	defer wg.Done()
	fmt.Println("Inside goroutine:: myFunc()")
	fmt.Println(10 + <-ch) //<-- According to rule, control will be blocked here until 'ch' sends some data so that it will be received in our myFunc() go routine.
}
func main() {

	fmt.Println("Start Main method")
	// Creating a channel
	ch := make(chan int)
	wg := sync.WaitGroup{}
	wg.Add(1)
	go myFunc(ch, &wg) //<-- This go routine started in a new thread

	time.Sleep(2 * time.Second) //<--- introduced a Sleep of 2 seconds to ensure that myFunc() go routine executes before main thread
	ch <- 10
	wg.Wait()
	fmt.Println("End Main method")
}

The channels are used here for synchronization and it works as described in documentation. It does not mean that the code starting from this point in the code will be executed at the same speed. It only means that main goroutine will not continue if myFunc goroutine is not reading from channel. And myFunc will wait for main goroutine to push data to channel. After this happen both goroutines will continue it execution independently.

Try this, used your code as basis

package main

import (
	"fmt"
	"time"
)

func myFunc(ch chan int, done chan struct{}) {
	defer close(done) // channel will be closed in the function exit phase
	fmt.Println("Inside goroutine:: myFunc()")
	fmt.Println(10 + <-ch) //<-- According to rule, control will be blocked here until 'ch' sends some data so that it will be received in our myFunc() go routine.
}
func main() {

	fmt.Println("Start Main method")
	// Creating a channel
	ch := make(chan int)
	done := make(chan struct{}) // signal channel

	go myFunc(ch, done) //<-- This go routine started in a new thread

	time.Sleep(2 * time.Second) //<--- introduced a Sleep of 2 seconds to ensure that myFunc() go routine executes before main thread
	ch <- 10
	<-done // waiting for function complete
	fmt.Println("End Main method")
}

Or use Jaroslaw's suggestion.

Because go is so fast... https://play.golang.org/p/LNyDAA3mGYY

After you send to channel scheduler isn't fast enoght... and program exists. I have introduced an additional context switcher for scheduler to show effect.

Yes, you are right

>I think, it is because main thread finished its execution first and hence, all other goroutine also terminated.

If you check the above program execution. The sleep is before main thread writes to the channel. Now even though which goroutine() will have CPU time is completely arbitary, but in the above case if the main sleeps before the explicit sleep logic. myFunc will be blocked as there is no data in ch

Here I made a slight change to the above code to make main sleep after writing data into Channel. It gives the expected output, Without using waitgroup or quit channels.

package main

import (
    "fmt"
    "time"
)

func myFunc(ch chan int) {
    fmt.Println("Inside goroutine:: myFunc()")
    fmt.Println(10 + <-ch) //<-- According to rule, control will be blocked here until 'ch' sends some data so that it will be received in our myFunc() go routine.
}
func main() {

    fmt.Println("Start Main method")
    // Creating a channel
    ch := make(chan int)

    go myFunc(ch) //<-- This go routine started in a new thread

   
    ch <- 10
    
    time.Sleep(2 * time.Second) //<--- introduced a Sleep of 2 seconds to ensure that myFunc() go routine executes before main thread


    fmt.Println("End Main method")
}

It is currently a race condition between the myFunc being able to print and your main function exiting.

If we look at the spec for program execution at
https://golang.org/ref/spec#Program_execution

> Program execution begins by initializing the main package and then invoking the function main. When that function invocation returns, the program exits. It does not wait for other (non-main) goroutines to complete.

It is still your job to make sure that all spawned goroutines will complete before your main goroutine exists.

In your case, you could use a waitgroup as you mentioned or you could use a done channel.
https://play.golang.org/p/RVr0HXuUMgn

Given your code you could also close the channel you use to send the integer over since you are passing it to the function as bidirectional but it's not strictly idiomatic.
https://play.golang.org/p/wGvexC5ZgIi