Struct SyncHashMap 

pub struct SyncHashMap<K, V> { /* private fields */ }

同步哈希映射，支持多读少写的场景 this sync map used to many reader, writer less. space-for-time strategy

Implementations

impl<K, V> SyncHashMap<K, V>

where K: Eq + Hash,

pub fn new_arc() -> Arc<Self>

创建一个新的Arc包装的SyncHashMap

pub fn new() -> Self

创建一个新的空映射

pub fn with_capacity(capacity: usize) -> Self

使用指定容量创建一个新的映射

pub const fn with_map(map: HashMap<K, V>) -> Self

使用现有的HashMap创建一个同步映射

pub fn insert(&self, k: K, v: V) -> Option<V>

插入键值对，使用写锁保护

pub fn insert_mut(&mut self, k: K, v: V) -> Option<V>

可变引用下的插入操作，无锁保护（调用者需确保线程安全）

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

移除键值对，使用写锁保护

pub fn remove_mut(&mut self, k: &K) -> Option<V>

可变引用下的移除操作，无锁保护（调用者需确保线程安全）

pub fn len(&self) -> usize

获取映射长度，使用读锁保护

pub fn is_empty(&self) -> bool

判断映射是否为空，使用读锁保护

pub fn clear(&self)

清空映射，使用写锁保护

pub fn clear_mut(&mut self)

可变引用下的清空操作，无锁保护（调用者需确保线程安全）

pub fn shrink_to_fit(&self)

收缩容量以适应元素数量，使用写锁保护

pub fn shrink_to_fit_mut(&mut self)

可变引用下的收缩容量操作，无锁保护（调用者需确保线程安全）

pub fn from(map: HashMap<K, V>) -> Self

从HashMap创建SyncHashMap的便捷方法

pub fn get<Q>(&self, k: &Q) -> Option<ReadGuard<'_, V>>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

获取键对应的值引用，使用读锁保护

返回一个 ReadGuard，在 guard 被释放前持有读锁，保证并发访问安全。

键可以是映射键类型的任何借用形式，但借用形式的 Hash 和 Eq 必须与键类型匹配。

Examples

use fast_able::SyncHashMap;

let map = SyncHashMap::new();
map.insert(1, "a");
assert_eq!(*map.get(&1).unwrap(), "a");
assert!(map.get(&2).is_none());

pub fn get_uncheck<Q>(&self, k: &Q) -> ReadGuard<'_, V>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

获取键对应的值引用（无检查版本），使用读锁保护

Panics

如果键不存在则 panic。

pub fn get_mut<Q>(&self, k: &Q) -> Option<WriteGuard<'_, V>>

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

获取键对应的可变值引用，使用写锁保护

返回一个 WriteGuard，在 guard 被释放前持有写锁，保证并发访问安全。

pub fn contains_key<Q>(&self, k: &Q) -> bool

where K: Borrow<Q>, Q: Hash + Eq + ?Sized,

检查是否包含指定的键，使用读锁保护

pub fn iter_mut(&self) -> IterMut<'_, K, V>

获取可变迭代器，使用写锁保护

pub fn iter(&self) -> Iter<'_, K, V>

获取只读迭代器，使用读锁保护

返回的迭代器持有读锁，在迭代期间保证数据不被修改。

pub fn dirty_ref(&self) -> ReadGuardMap<'_, K, V>

获取底层HashMap的只读引用，使用读锁保护

返回一个 ReadGuardMap，在 guard 被释放前持有读锁。

pub unsafe fn dirty_ref_unsafe(&self) -> &HashMap<K, V>

获取底层HashMap的不安全引用（无锁保护）

Safety

调用者需确保没有并发写操作。

pub fn into_inner(self) -> HashMap<K, V>

消耗self并返回内部的HashMap

pub fn keys(&self) -> KeysGuard<'_, K, V>

获取键的迭代器，使用读锁保护

返回的迭代器持有读锁，在迭代期间保证数据不被修改。

pub fn values(&self) -> ValuesGuard<'_, K, V>

获取值的只读迭代器，使用读锁保护

返回的迭代器持有读锁，在迭代期间保证数据不被修改。

pub fn values_mut(&self) -> ValuesMutGuard<'_, K, V>

获取值的可变迭代器，使用写锁保护

返回的迭代器持有写锁，在迭代期间保证独占访问。

pub fn retain<F>(&self, f: F)

where F: FnMut(&K, &mut V) -> bool,

保留满足条件的元素，使用写锁保护

pub fn capacity(&self) -> usize

获取映射的容量，使用读锁保护

pub fn reserve(&self, additional: usize)

预留指定容量，使用写锁保护

pub fn remove_entry(&self, k: &K) -> Option<(K, V)>

尝试移除键值对，如果键存在则返回被移除的值，使用写锁保护

pub fn get_or_insert(&self, k: K, default: V) -> WriteGuard<'_, V>

如果键存在则返回其可变引用，否则插入新值，使用写锁保护

返回一个 WriteGuard，在 guard 被释放前持有写锁，保证并发访问安全。

pub fn get_or_insert_with<F>(&self, k: K, default: F) -> WriteGuard<'_, V>

where F: FnOnce() -> V,

如果键存在则返回其可变引用，否则使用函数返回值插入，使用写锁保护

返回一个 WriteGuard，在 guard 被释放前持有写锁，保证并发访问安全。

Trait Implementations

impl<K, V> Clone for SyncHashMap<K, V>

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

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<K, V> Debug for SyncHashMap<K, V>

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

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

Formats the value using the given formatter.

impl<K, V> Default for SyncHashMap<K, V>

where K: Eq + Hash,

fn default() -> Self

Returns the “default value” for a type.

impl<'de, K, V> Deserialize<'de> for SyncHashMap<K, V>

where K: Eq + Hash + Deserialize<'de>, V: Deserialize<'de>,

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, V> From<HashMap<K, V>> for SyncHashMap<K, V>

where K: Eq + Hash,

fn from(map: HashMap<K, V>) -> Self

Converts to this type from the input type.

impl<K, V> Index<&K> for SyncHashMap<K, V>

where K: Eq + Hash,

索引操作，无锁访问

Safety

此操作不持有锁，仅应在确保没有并发写入时使用。 如需线程安全访问，请使用 get 方法。

type Output = V

The returned type after indexing.

fn index(&self, index: &K) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<'a, K, V> IntoIterator for &'a SyncHashMap<K, V>

where K: Eq + Hash,

type Item = (&'a K, &'a V)

The type of the elements being iterated over.

type IntoIter = Iter<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V> IntoIterator for SyncHashMap<K, V>

where K: Eq + Hash,

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<K, V> PartialEq for SyncHashMap<K, V>

where K: Eq + Hash, V: PartialEq,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K, V> Serialize for SyncHashMap<K, V>

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

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, V> Eq for SyncHashMap<K, V>

where K: Eq + Hash, V: Eq,

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

标记为Send，因为使用了UnsafeCell但有锁保护 this is safety, dirty mutex ensure

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

标记为Sync，因为使用了UnsafeCell但有锁保护 this is safety, dirty mutex ensure