How to signal if a value has been read from a channel in Go

I am reading values that are put into a channel ch via an infinite for. I would like some way to signal if a value has been read and operated upon (via the sq result) and add it to some sort of counter variable upon success. That way I have a way to check if my channel has been exhausted so that I can properly exit my infinite for loop.

Currently it is incrementing regardless if a value was read, thus causing it to exit early when the counter == num. I only want it to count when the value has been squared.

EDIT: Another approach I have tested is to receive the ok val out of the channel upon reading and setting val and then check if !ok { break }. However I receive a deadlock panic since the for did has not properly break. Example here: https://go.dev/play/p/RYNtTix2nm2

package main

import "fmt"

func main() {

	num := 5

    // Buffered channel with 5 values.
	ch := make(chan int, num)
	defer close(ch)

	for i := 0; i < num; i++ {
		go func(val int) {
			fmt.Printf("Added value: %d to the channel\n", val)
			ch <- val
		}(i)
	}

	// Read from our channel infinitely and increment each time a value has been read and operated upon
	counter := 0
	for {
		// Check our counter and if its == num then break the infinite loop
		if counter == num {
			break
		}
		val := <-ch
        counter++
		go func(i int) {
			// I'd like to verify a value was read from ch & it was processed before I increment the counter
			sq := i * i
			fmt.Println(sq)
		}(val)
	}
}

let me try to help you in figuring out the issue.

Reading issue

The latest version of the code you put in the question is working except when you're about to read values from the ch channel. I mean with the following code snippet:

go func(i int) {
  // I'd like to verify a value was read from ch & it was processed before I increment the counter
  sq := i * I
  fmt.Println(sq)
}(val)

In fact, it's not needed to spawn a new goroutine for each read. You can consume the messages as soon as they arrived in the ch channel. This is possible due to writing done inside goroutines. Thanks to them, the code can go ahead and reach the reading phase without being blocked.

Buffered vs unbuffered

In this scenario, you used a buffered channel with 5 slots for data. However, if you're relying on the buffered channel you should signal when you finish sending data to it. This is done with a close(ch) invocation after all of the Go routines finish their job. If you use an unbuffered channel it's fine to invoke defer close(ch) next to the channel initialization. In fact, this is done for cleanup and resource optimization tasks. Back to your example, you can change the implementation to use unbuffered channels.

Final Code

Just to recap, the two small changes that you've to do are:

1. Use an unbuffered channel instead of a buffered one.
2. Do Not use a Go routine when reading the messages from the channel.

Please be sure to understand exactly what's going on. Another tip can be to issue the statement: fmt.Println("NumGoroutine:", runtime.NumGoroutine()) to print the exact number of Go routines running in that specific moment.

The final code:

package main

import (
	"fmt"
	"runtime"
)

func main() {
	num := 5

	// Buffered channel with 5 values.
	ch := make(chan int)
	defer close(ch)

	for i := 0; i < num; i++ {
		go func(val int) {
			fmt.Printf("Added value: %d to the channel\n", val)
			ch <- val
		}(i)
	}

	fmt.Println("NumGoroutine:", runtime.NumGoroutine())

	// Read from our channel infinitely and increment each time a value has been read and operated upon
	counter := 0
	for {
		// Check our counter and if its == num then break the infinite loop
		if counter == num {
			break
		}
		val := <-ch
		counter++
		func(i int) {
			// I'd like to verify a value was read from ch & it was processed before I increment the counter
			sq := i * i
			fmt.Println(sq)
		}(val)
	}
}

Let me know if this helps you, thanks!