Implementing Send and Sync Traits in Rust

Rust's ownership and borrowing system guarantees memory safety, but it also needs mechanisms to ensure data safety when dealing with concurrency. The Send and Sync traits are crucial for this purpose. This challenge asks you to implement these traits for a custom data structure, demonstrating your understanding of how they work and their implications for concurrent access.

Problem Description

You are tasked with creating a simple, thread-safe counter data structure called SafeCounter. This counter should be able to be safely shared between multiple threads. To achieve this, you'll need to implement the Send and Sync traits for your SafeCounter struct.

What needs to be achieved:

1. Create a struct SafeCounter that holds an integer representing the counter's value.
2. Implement the Send trait for SafeCounter. This indicates that values of type SafeCounter can be safely transferred between threads.
3. Implement the Sync trait for SafeCounter. This indicates that values of type SafeCounter can be safely shared between threads via shared references (& and &mut).
4. Provide a Mutex-protected increment method to safely increment the counter's value from multiple threads.

Key requirements:

• The SafeCounter struct must be Send and Sync.
• The increment method must safely increment the counter's value, preventing data races.
• The code must compile and run without errors.

Expected behavior:

• Multiple threads should be able to concurrently call the increment method on the same SafeCounter instance without causing data races or undefined behavior.
• The final counter value should reflect the total number of increments performed by all threads.

Edge cases to consider:

• What happens if the Mutex within SafeCounter is poisoned (e.g., a thread panics while holding the lock)? While you don't need to handle poisoning explicitly, be aware of its potential impact.
• Consider the implications of making SafeCounter not Sync. What would that mean for its usage in a concurrent environment? (You don't need to implement this, just understand the concept).

Examples

Example 1:

Input: Two threads, each calling `increment` 1000 times on a `SafeCounter`.
Output: The final counter value should be 2000.
Explanation: Both threads safely increment the counter, and the final value reflects the combined increments.

Example 2:

Input: Four threads, each calling `increment` 500 times on a `SafeCounter`.
Output: The final counter value should be 2000.
Explanation: The `Mutex` ensures that increments are atomic, preventing race conditions.

Example 3: (Edge Case - demonstrating thread safety)

Input: Ten threads, each calling `increment` 200 times on a `SafeCounter`.  The threads are started concurrently.
Output: The final counter value should be 2000.
Explanation: Even with a large number of threads and concurrent access, the `Mutex` protects the counter's value, ensuring correctness.

Constraints

• The SafeCounter struct must only contain a single i32 field and a Mutex<i32>.
• The increment method must be thread-safe.
• The solution must compile and run using the standard Rust toolchain.
• Performance is not a primary concern for this challenge; correctness is paramount.

Notes

• The Send and Sync traits are automatically implemented for many common types in Rust. However, for custom types, you often need to implement them explicitly.
• The Mutex type from the std::sync module is a common way to protect shared data from concurrent access.
• Think carefully about what it means for a type to be Send and Sync. Send means it's safe to move across thread boundaries. Sync means it's safe to share a reference to it across thread boundaries.
• Consider how the Mutex contributes to the Send and Sync implementation of SafeCounter.