Concurrent Counter with Atomic Types

This challenge focuses on implementing a simple counter that is thread-safe using Rust's atomic types. Understanding and utilizing atomic types is crucial for writing correct and efficient concurrent programs, preventing data races and ensuring predictable behavior in multi-threaded environments. You'll be building a counter that can be safely incremented by multiple threads simultaneously.

Problem Description

You are tasked with creating a ConcurrentCounter struct that encapsulates an atomic integer. This struct should provide the following methods:

new(): A constructor that initializes the counter to 0.
increment(): An atomic increment operation. This method should increment the counter by 1 using an atomic operation.
value(): Returns the current value of the counter. This should also be an atomic read operation.

The core requirement is that all operations on the counter must be thread-safe. This means multiple threads can call increment() concurrently without causing data races or inconsistent results. The value() method should return the most up-to-date value, even if other threads are concurrently incrementing it.

Key Requirements:

Use Rust's AtomicI32 type for the counter.
Ensure thread safety using atomic operations.
Provide a clear and concise implementation.
The increment() method should not return a value.
The value() method should return an i32.

Expected Behavior:

When multiple threads concurrently call increment() on the ConcurrentCounter, the final value of the counter should be equal to the total number of increments performed across all threads. The value() method should always return a consistent value, reflecting the latest atomic state of the counter.

Edge Cases to Consider:

Very high increment rates from multiple threads.
Reading the value while another thread is incrementing it.
The counter starting at a non-zero value (although the problem specifies initialization to 0, consider how your solution would handle a different initial value).

Examples

Example 1:

Input: Two threads, each calling increment() 1000 times.
Output: 2000
Explanation: Both threads increment the counter concurrently. The final value should be the sum of increments from both threads.

Example 2:

Input: One thread calls increment() 5 times, then another thread calls increment() 3 times.
Output: 8
Explanation: The counter is incremented a total of 8 times.

Example 3: (Edge Case - Concurrent Read/Write)

Input: Thread 1 calls increment() concurrently with Thread 2 calling value().
Output: Thread 2 returns a value that is consistent with the ongoing increment operation.  For example, if Thread 1 is in the middle of incrementing, Thread 2 might see the value before or after the increment, but it will be a valid state of the counter.
Explanation: Atomic operations guarantee that the read from `value()` will not observe a partially updated state.

Constraints

The counter should be implemented using AtomicI32.
The increment() method should not block.
The value() method should not block.
The solution should compile and run without panics.
Performance is not a primary concern, but the solution should be reasonably efficient.

Notes

Rust's AtomicI32 provides methods like fetch_add for atomic operations. Explore these methods to ensure thread safety.
Consider the memory model implications of atomic operations. Rust's memory model helps ensure data consistency across threads.
Think about how to avoid data races when multiple threads access and modify the counter concurrently. Atomic operations are key to preventing these issues.
Testing with multiple threads is crucial to verify the correctness of your implementation. You can use Rust's standard library threading features for testing.