# threadsafe-lru
This is a thread-safe implementation of an LRU (Least Recently Used) cache in Rust.
The `LruCache` struct uses sharding to improve concurrency by splitting the cache into multiple smaller segments, each protected by a mutex.
## Example Usage
```rust
use threadsafe_lru::LruCache;
fn main() {
// Create a new LRU cache with 4 shards and capacity of 2 per shard
let cache = LruCache::new(4, 2);
// Insert items into the cache
let five = 5;
let six = 6;
assert_eq!(cache.insert(five, 10), None);
assert_eq!(cache.insert(six, 20), None);
// Retrieve an item from the cache
assert_eq!(cache.get(&five), Some(10));
// Promote an item to make it more recently used
cache.promote(&five);
// Remove an item from the cache
assert_eq!(cache.remove(&five), Some(10));
}
```
In this example, a new `LruCache` is created with 4 shards and a capacity of 2 entries per shard.
Items are inserted using the `insert` method.
The `get` method retrieves an item by key, promoting it to the most recently used position.
Finally, the `remove` method deletes an item from the cache.
This implementation ensures that operations on different keys can be performed concurrently without causing race conditions due to shared state.
## API Documentation
For detailed documentation, including all methods and usage examples, refer to the [LruCache API on docs.rs](https://docs.rs/threadsafe-lru/latest/threadsafe_lru/).
## Testing
LruCache is thoroughly tested with a suite of unit tests covering various operations. You can run the tests using `cargo test`:
```sh
cargo test
```
This ensures that all functionalities work as expected and helps maintain high code quality.
## License
LruCache is licensed under the MIT license. See [LICENSE](LICENSE) for more details.