why there is deadlock although i tried closing the channel after sending all values

why there is deadlock after printing all values ?
what i understand
as from receiving part code channel is waiting which letting to block or pause main go routine although i tried with waitgroup doesn't work

package main

import (
	"fmt"
	//"sync"
)

//output  from 10 20 30 ... - 100
func main() {
	//wg := sync.WaitGroup{}

	done := make(chan int)
	for i := 1; i <= 10; i++ {
		//wg.Add(1)
		go func(i int) {

			done <- i * 10
		}(i)
		// close(done)
	}
	//	close(done)
	//wg.Wait()

	// for item := range done{
	// fmt.Println(item)}
	for {
		if value, ok := <-done; ok {
			fmt.Println("received is ", value)
		} else {
			return
			//os.Exit(1)
		}
	}
}

Because you never close the channel. So the value, ok := <-done part is always waiting for the 11th value that will never come.

Replacing this part should do the trick:

for i := 1; i <= 10; i++ {
    //wg.Add(1)
    go func(i int) {

        done <- i * 10
    }(i)
    // close(done)
}

new:

go func(){
   for i := 1; i <= 10; i++ {
            done <- i * 10 
    }
    close(done)
}()

As per the answer from @aureliar value, ok := <-done will block until a value is received on the channel or the channel is closed (and, once your goroutines complete, neither of these happen). From your question and the comments in your code it looks like you were close to working out how to solve this by waiting for the goroutines to complete and closing the channel.

Because you know the number of goroutines in advance (and each goroutine always sends one value on the channel) there is a simple solution (playground):

func main() {
	noOfGoRoutines := 10
	done := make(chan int)
	for i := 1; i <= noOfGoRoutines; i++ {
		go func(i int) {
			done <- i * 10
		}(i)
	}

	for noOfGoRoutines > 0 {
		value := <-done
		fmt.Println("received is ", value)
		noOfGoRoutines--
	}
}

Things get a bit more complicated when you don't know how many values will be received in advance. In that case closing the channel is a good way of letting the receiver know you have finished. In your case this means closing the channel after the goroutines have completed (this is important because sending to a closed channel leads to a panic).

To do this using a WaitGroup you will need three functions:

• wg.Add(delta int) to set the counter. The call you have commented out is fine but an alternative is to call wg.Add(10) before entering the loop.
• wg.Done() "decrements the WaitGroup counter by one" - you need to call this before each goroutine ends (its common to defer the call). This was missing from your code.
• wg.Wait() "blocks until the WaitGroup counter is zero".

With the above in place you can safely call close(done) knowing that nothing further will be sent to the channel. However there is a complication - if you just add this code after your first loop you will hit another deadlock because your goroutines will all block at done <- i * 10. This happens because main will be blocked at wg.Wait() meaning nothing is receiving from the channel and as per the spec:

>If the capacity is zero or absent, the channel is unbuffered and communication succeeds only when both a sender and receiver are ready.

This can be solved by waiting/closing within another goroutine.

You can try this in the playground.

package main

import (
	"fmt"
	"sync"
)

//output  from 10 20 30 ... - 100
func main() {
	wg := sync.WaitGroup{}

	done := make(chan int)
	for i := 1; i <= 10; i++ {
		wg.Add(1)
		go func(i int) {
			done <- i * 10
			wg.Done()
		}(i)
	}

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

	for value := range done {
		fmt.Println("received is ", value)
	}
	fmt.Println("channel closed")

	/* I have simplified your loop but this would also work
	for {
		if value, ok := <-done; ok {
			fmt.Println("received is ", value)
		} else {
			fmt.Println("channel closed")
			return
		}
	}
	*/
}