go concurrency all goroutines are asleep - deadlock

Sorry about the noob question but I'm having a hard time wrapping my head around the concurrency part of go. Basically this program below is a simplified version of a larger one I'm writing, thus I want to keep the structure similar to below.

Basically instead of waiting 4 seconds I want to run addCount(..) concurrent using the unbuffered channel and when all elements in the int_slice has been processed I want to do another operation on them. However this program ends with a "panic: close of closed channel" and if I remove the closing of the channel I'm getting the output I'm expecting but it panics with: "fatal error: all goroutines are asleep - deadlock"

How can I implement the concurrency part correctly in this scenario?

Thanks in advance!

package main

import (
    "fmt"
    "time"
)

func addCount(num int, counter chan<- int) {
    time.Sleep(time.Second * 2)
    counter <- num * 2
}

func main() {
    counter := make(chan int)
    int_slice := []int{2, 4}

    for _, item := range int_slice {
  	    go addCount(item, counter)
        close(counter)
    }

    for item := range counter {
	    fmt.Println(item)
    }
}

Here are the issues I spotted in the code, and below a working version based on your implementation.

• If a goroutine tries to write to an "unbuffered" channel, it will block until someone reads from it. Since you are not reading until they finish writing to the channel, you have a deadlock there.

• Closing the channel while they are blocked breaks the deadlock, but gives an error since they now can't write to a closed channel.

Solution involves:

• Creating a buffered channel so that they can write without blocking.

• Using a sync.WaitGroup so that you wait for the goroutines to finish before closing the channel.

• Reading from the channel at the end, when all is done.

See here, with comments:

	package main
	
	import (
	    "fmt"
	    "time"
		"sync"
	)
	
	func addCount(num int, counter chan<- int, wg *sync.WaitGroup) {
        // clear one from the sync group
		defer wg.Done()
	    time.Sleep(time.Second * 2)
	    counter <- num * 2
	}
	
	func main() {
	    int_slice := []int{2, 4}
        // make the slice buffered using the slice size, so that they can write without blocking
		counter := make(chan int, len(int_slice))
	
		var wg sync.WaitGroup
	
	    for _, item := range int_slice {
            // add one to the sync group, to mark we should wait for one more
	    	wg.Add(1)
	        go addCount(item, counter, &wg)
	    }
	    
        // wait for all goroutines to end
		wg.Wait()
		
        // close the channel so that we not longer expect writes to it
		close(counter)
	
        // read remaining values in the channel
	    for item := range counter {
	        fmt.Println(item)
	    }
	
	}

For the sake of having examples here's a slightly modified version of what @eugenioy submitted. It allows for the use of an unbuffered channel and the reading of values as they come in instead of at the end like a regular for loop.

package main

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

func addCount(num int, counter chan<- int, wg *sync.WaitGroup) {
	// clear one from the sync group
	defer wg.Done()
    // not needed, unless you wanted to slow down the output
	time.Sleep(time.Second * 2)
	counter <- num * 2
}

func main() {
	// variable names don't have underscores in Go
	intSlice := []int{2, 4}
	
	counter := make(chan int)

	var wg sync.WaitGroup

	for _, item := range intSlice {
		// add one to the sync group, to mark we should wait for one more
		wg.Add(1)
		go addCount(item, counter, &wg)
	}

	// by wrapping wait and close in a go routine I can start reading the channel before its done, I also don't need to know the size of the
	// slice
	go func() {
		wg.Wait()
		close(counter)
	}()

	for item := range counter {
		fmt.Println(item)
	}
}

package main

import (
	"fmt"
	"time"
)

func addCount(num int, counter chan <- int) {
	time.Sleep(time.Second * 2)
    counter <- num * 2
}

func main() {
    counter := make(chan int)
	int_slice := []int{2, 4}

    for _, item := range int_slice {
    	go addCount(item, counter)

    	fmt.Println(<-counter)
	}
}