Graceful Shutdown: Implementing Channel Closing in Go

In concurrent Go programs, it's crucial to have a mechanism to signal to goroutines that they should stop processing and exit gracefully. Channels are a powerful tool for communication and synchronization, and closing a channel is the idiomatic way to signal that no more values will be sent on it. This challenge focuses on correctly implementing and utilizing channel closing to manage goroutine lifecycles.

Problem Description

You are tasked with building a system where multiple worker goroutines consume data from a channel. A main goroutine is responsible for sending data to this channel and, at some point, needs to signal to the workers that no more data will be sent.

Your goal is to implement this signaling mechanism using channel closing. When the main goroutine closes the channel, all worker goroutines should detect this closure and terminate their processing loop.

Key Requirements:

1. Producer (Main Goroutine): A goroutine that sends a finite number of integers (e.g., 1 to 5) to a channel. After sending all values, it must close the channel.
2. Consumers (Worker Goroutines): Multiple goroutines that receive values from the same channel. Each worker should continue receiving values until the channel is closed.
3. Termination Detection: Workers must reliably detect when the channel is closed and exit their receiving loop.
4. Output: Each worker should print the values it receives. After a worker finishes processing (due to channel closure), it should print a message indicating it's shutting down.

Expected Behavior:

The main goroutine will send a set of numbers. All worker goroutines will concurrently receive and print these numbers. Once the main goroutine has sent all its numbers, it will close the channel. Upon detecting the closure, each worker will finish processing any remaining buffered values and then gracefully exit, printing its shutdown message. The program should terminate only after all workers have shut down.

Edge Cases:

• What happens if a worker tries to receive from a closed channel?
• What if multiple workers are active?
• What if the producer sends zero values before closing?

Examples

Example 1:

Input: The producer will send integers 1, 2, 3 to the channel. Two worker goroutines will consume from this channel.

Output (order of worker output may vary):
Worker 1 received: 1
Worker 2 received: 1
Worker 1 received: 2
Worker 2 received: 2
Worker 1 received: 3
Worker 2 received: 3
Worker 1 shutting down.
Worker 2 shutting down.

Explanation: The producer sends 1, 2, and 3. Both workers receive and print these values concurrently. After sending 3, the producer closes the channel. Both workers detect the closure, finish any potential processing (in this case, they've already received all values), and print their shutdown messages.

Example 2:

Input: The producer will send integers 10, 20 to the channel. One worker goroutine will consume from this channel.

Output:
Worker 1 received: 10
Worker 1 received: 20
Worker 1 shutting down.

Explanation: The producer sends 10 and 20. The single worker receives and prints them. The producer then closes the channel. The worker detects the closure and prints its shutdown message.

Example 3: Producer sends no values before closing.

Input: The producer will send no values before closing the channel. Three worker goroutines will consume from this channel.

Output (order of worker output may vary):
Worker 1 shutting down.
Worker 2 shutting down.
Worker 3 shutting down.

Explanation: The producer closes the channel immediately. All workers, upon attempting to receive, will detect the closed channel and immediately print their shutdown messages.

Constraints

• The number of values sent by the producer will be between 0 and 10.
• The number of worker goroutines will be between 1 and 5.
• The channel used for communication should be unbuffered for this challenge to better illustrate immediate closure detection.
• The program must demonstrate correct termination; no goroutines should be left running indefinitely.

Notes

• Remember the for range loop over a channel or the comma-ok idiom (value, ok := <-channel) are the primary ways to detect channel closure when receiving.
• Use sync.WaitGroup to ensure the main goroutine waits for all worker goroutines to complete their shutdown before the program exits.
• Consider how to pass the channel and any necessary synchronization primitives to your worker goroutines.