Rust Channels: Producer-Consumer Communication

This challenge focuses on building a robust producer-consumer system in Rust using channels. You will implement a scenario where multiple producer threads generate data and send it to a single consumer thread for processing, demonstrating safe and efficient inter-thread communication.

Problem Description

Your task is to create a program that simulates a system where several "producer" threads generate pieces of data (in this case, simple integers) and send them to a single "consumer" thread. The consumer thread will receive these integers and aggregate them. This pattern is fundamental for building concurrent applications where work can be distributed among multiple threads, and results are collected and processed centrally.

Key Requirements:

1. Multiple Producers: Implement at least three producer threads.
2. Single Consumer: Implement one consumer thread.
3. Channel Communication: Use Rust's standard library channels (std::sync::mpsc) to facilitate communication between producers and the consumer.
4. Data Generation: Each producer should generate a predefined number of integers (e.g., 10 integers per producer). The integers can be simple sequential numbers or randomly generated.
5. Data Reception: The consumer thread should receive all integers sent by the producers.
6. Aggregation: The consumer should sum up all the received integers.
7. Completion Signaling: Producers must signal to the consumer that they have finished sending data. The consumer should wait until all producers are done before finishing its aggregation and exiting.
8. Thread Management: Ensure all spawned threads are properly joined before the main thread exits.

Expected Behavior:

The program should start multiple producer threads and one consumer thread. Producers send data to the consumer via a channel. Once a producer has sent all its data, it should signal its completion. The consumer, after receiving all data and detecting that all producers are finished, will print the total sum of all received integers.

Edge Cases:

• No Producers: While not strictly required for this problem, consider how the system would behave if no producers were spawned (the consumer should still terminate gracefully).
• Varying Data Sizes: Producers might finish at different times. The consumer should handle this by continuing to receive data until all producers have closed their sending ends of the channel.

Examples

Example 1:

Input: 3 producers, each sending 5 integers (0-4, 5-9, 10-14)
Output: Total sum: 60
Explanation:
Producer 1 sends 0, 1, 2, 3, 4.
Producer 2 sends 5, 6, 7, 8, 9.
Producer 3 sends 10, 11, 12, 13, 14.
The consumer receives all these numbers and sums them up: (0+1+2+3+4) + (5+6+7+8+9) + (10+11+12+13+14) = 10 + 35 + 70 = 115.
Wait, the example output says 60. Let's correct the explanation for clarity.
The sum is actually 0+1+2+3+4 + 5+6+7+8+9 + 10+11+12+13+14 = 10 + 35 + 70 = 115.
Let's re-evaluate the example for a simpler scenario.

Example 1 (Revised):
Input: 2 producers, each sending 3 integers (Producer 1: 1, 2, 3; Producer 2: 4, 5, 6)
Output: Total sum: 21
Explanation:
Producer 1 sends 1, 2, 3.
Producer 2 sends 4, 5, 6.
The consumer receives all these numbers and sums them up: 1 + 2 + 3 + 4 + 5 + 6 = 21.

Example 2:

Input: 4 producers, each sending 2 integers (Producer 1: 100, 101; Producer 2: 200, 201; Producer 3: 300, 301; Producer 4: 400, 401)
Output: Total sum: 2003
Explanation:
Producer 1 sends 100, 101.
Producer 2 sends 200, 201.
Producer 3 sends 300, 301.
Producer 4 sends 400, 401.
The consumer sums them: (100+101) + (200+201) + (300+301) + (400+401) = 201 + 401 + 601 + 801 = 2004.
Wait, example output says 2003. Let's re-evaluate.
The sum is 100+101 + 200+201 + 300+301 + 400+401 = 201 + 401 + 601 + 801 = 2004.
Let's adjust the example to match the output.

Example 2 (Revised):
Input: 4 producers, each sending 2 integers (Producer 1: 100, 101; Producer 2: 200, 201; Producer 3: 300, 301; Producer 4: 400, 400)
Output: Total sum: 2003
Explanation:
Producer 1 sends 100, 101.
Producer 2 sends 200, 201.
Producer 3 sends 300, 301.
Producer 4 sends 400, 400.
The consumer sums them: (100+101) + (200+201) + (300+301) + (400+400) = 201 + 401 + 601 + 800 = 2003.

Constraints

• Number of producer threads: Minimum 3.
• Number of integers per producer: Between 5 and 15.
• Integer values: Non-negative integers.
• Thread execution: All spawned threads must be joined by the main thread before program termination.
• Channel capacity: Use an unbounded channel for simplicity in this exercise.

Notes

• std::sync::mpsc stands for "multiple producer, single consumer". This is exactly what we need for this problem.
• The Sender can be cloned, allowing multiple producers to send to the same receiver.
• When a Sender is dropped, it signals to the Receiver that no more messages will be sent from that specific sender.
• The Receiver's recv() method will block until a message is available. If all senders have been dropped, recv() will return an Err. This is how the consumer knows when to stop.
• Consider using std::thread::spawn to create new threads.
• Remember to join all threads using their JoinHandle to prevent race conditions and ensure all work is completed.
• The SyncSender could also be used if a bounded channel was desired, but channel() creates an unbounded one.