Struct ConcurrentHashMap 

pub struct ConcurrentHashMap<K, V, S = RandomState> { /* private fields */ }

A concurrent hash map using shard-level locking for high throughput.

The map is split into N independent shards, each protected by its own mutex. This dramatically reduces contention compared to a single global lock when many threads operate on different keys simultaneously.

Implementations

impl<K, V> ConcurrentHashMap<K, V, RandomState>

where K: Eq + Hash + Clone, V: Clone,

pub fn new() -> Self

Create a new concurrent hash map with the default number of shards.

pub fn with_shard_count(n: usize) -> Self

Create a concurrent hash map with the specified number of shards.

impl<K, V, S> ConcurrentHashMap<K, V, S>

where K: Eq + Hash + Clone, V: Clone, S: BuildHasher + Clone,

pub fn insert(&self, key: K, value: V) -> Option<V>

Insert a key-value pair, returning the previous value if the key already existed.

pub fn get(&self, key: &K) -> Option<V>

Retrieve a clone of the value associated with the key.

pub fn remove(&self, key: &K) -> Option<V>

Remove a key and return its value.

pub fn contains_key(&self, key: &K) -> bool

Check whether the map contains the key.

pub fn len(&self) -> usize

Approximate number of entries (may be slightly stale under contention).

pub fn is_empty(&self) -> bool

Whether the map is empty.

pub fn get_and_modify<F, R>(&self, key: &K, f: F) -> Option<R>

where F: FnOnce(&mut V) -> R,

Apply a function to the value associated with key, returning the result.

If the key doesn’t exist, returns None.

pub fn get_or_insert_with<F>(&self, key: K, f: F) -> V

where F: FnOnce() -> V,

Insert if the key does not already exist, using a closure to create the value.

Returns a clone of the existing or newly-inserted value.

pub fn keys(&self) -> Vec<K>

Collect all keys into a Vec.

pub fn clear(&self)

Clear all entries.

Trait Implementations

impl<K, V> Default for ConcurrentHashMap<K, V, RandomState>

where K: Eq + Hash + Clone, V: Clone,

fn default() -> Self

Returns the “default value” for a type.

impl<K: Send, V: Send, S: Send> Send for ConcurrentHashMap<K, V, S>

impl<K: Send + Sync, V: Send + Sync, S: Send + Sync> Sync for ConcurrentHashMap<K, V, S>