Concurrent Channel Communication in Rust

This challenge focuses on implementing a simple channel communication system in Rust using threads and channels. Channel communication is a fundamental pattern in concurrent programming, allowing different parts of a program to exchange data safely. Successfully completing this challenge will demonstrate your understanding of Rust's concurrency primitives and how to use them to build robust, multi-threaded applications.

Problem Description

You are tasked with creating a system where multiple producer threads send data to a single consumer thread through a channel. The producers will generate a sequence of numbers, and the consumer will sum these numbers. The system should handle multiple producers concurrently, ensuring that the consumer receives all data and calculates the correct sum.

What needs to be achieved:

• Create a channel using std::sync::mpsc.
• Spawn multiple producer threads.
• Each producer thread should send a specific number of messages to the channel.
• Create a consumer thread that receives messages from the channel and calculates their sum.
• The consumer thread should terminate gracefully when all producers have finished sending data and the channel is empty.

Key Requirements:

• The code must be thread-safe.
• The consumer must accurately calculate the sum of all messages sent by all producers.
• The program should terminate cleanly without panicking.
• Use mpsc::Sender and mpsc::Receiver for channel communication.

Expected Behavior:

The program should print the final sum calculated by the consumer thread. The sum should be the total of all numbers sent by all producers.

Edge Cases to Consider:

• What happens if a producer thread panics? (While not required to handle this explicitly, consider the implications for the overall program state).
• How does the consumer know when all producers have finished sending data? (The channel will close when all senders are dropped).

Examples

Example 1:

Input: 2 producers, each sending 5 numbers: [1, 2, 3, 4, 5] and [6, 7, 8, 9, 10]
Output: 55
Explanation: The consumer receives [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] and calculates their sum, which is 55.

Example 2:

Input: 3 producers, each sending 3 numbers: [10, 20, 30], [40, 50, 60], [70, 80, 90]
Output: 450
Explanation: The consumer receives [10, 20, 30, 40, 50, 60, 70, 80, 90] and calculates their sum, which is 450.

Example 3: (Edge Case - Empty Channel)

Input: 0 producers (no producers send any data)
Output: 0
Explanation: The consumer receives no data and returns a sum of 0.

Constraints

• The number of producers can range from 1 to 10.
• Each producer can send between 1 and 20 numbers.
• The numbers sent by each producer will be integers between 1 and 100 (inclusive).
• The program should complete within 1 second. (This is a soft constraint, primarily to encourage efficient code).

Notes

• Consider using move closures to transfer ownership of data to the producer threads.
• The mpsc channel automatically handles synchronization and data transfer between threads.
• The consumer thread should block until the channel is closed and empty. Use recv() in a loop to achieve this.
• Think about how to signal to the consumer thread that all producers have finished sending data. The channel closing handles this automatically.
• Focus on clarity and correctness. While performance is a consideration, prioritize a well-structured and understandable solution.