Struct concurrent_lru::unsharded::LruCache

pub struct LruCache<K, V> { /* fields omitted */ }

A concurrent LRU cache.

A value is pinned while its CacheHandle is live, and thus cannot be evicted. Capacity specifies how many values could be cached, including pinned and unpinned. Eviction happens when #value > capacity, or Lru::prune is called.

Keys should be lightweight, while values could be heavyweight. That is, creating (Lru::get_or_init) and dropping value could be time-consuming, and the cache itself would not be blocked.

Implementations

impl<K, V> LruCache<K, V> where
    K: Send + Sync + Hash + Eq + Clone,
    V: Send + Sync, 

pub fn new(capacity: u64) -> Self

impl<K, V> LruCache<K, V> where
    K: Hash + Eq + Clone, 

pub fn advice_evict(&self, key: K)

Evict a value if it is present and unpinned.

pub fn prune(&self)

Prune all unpinned values.

pub fn total_charge(&self) -> u64

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

Get the cache handle for the key, return None if not present. The value is pinned in cache while the cache handle is live.

pub fn get_or_try_init<E>(
    &self,
    key: K,
    charge: u64,
    init: impl FnOnce(&K) -> Result<V, E>
) -> Result<CacheHandle<'_, K, V>, E>

Error handling version of get_or_init. Value is not inserted if error occurs.

pub fn get_or_init(
    &self,
    key: K,
    charge: u64,
    init: impl FnOnce(&K) -> V
) -> CacheHandle<'_, K, V>

Get the cache handle for the key, initialize the value if not present. The value is pinned in cache while the cache handle is live.

Multiple threads calling get_or_init on the same key is fine. The value would be constructed exactly once.

Trait Implementations

impl<K, V> Debug for LruCache<K, V> where
    K: Debug,
    V: Debug, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<K, V> Send for LruCache<K, V>

impl<K, V> Sync for LruCache<K, V>