Struct SyncVec 

pub struct SyncVec<V> { /* private fields */ }

Synchronous vector supporting fine-grained lock control 同步向量类型，支持细粒度锁控制，更安全地访问数据

Locking strategy:

• Read operations like get: Vec read lock + value read lock
• Value modification operations like get_mut: Vec read lock + value write lock
• Structure modification operations like push/remove: Vec write lock 锁策略:
• get 等读取操作: Vec读锁 + 值的读锁
• get_mut 等修改值操作: Vec读锁 + 值的写锁
• push/remove 等修改结构操作: Vec写锁

This allows:

• Multiple threads can read different values simultaneously
• When one thread modifies a value, other threads can still read other values
• Exclusive access when modifying the Vec structure 这样可以实现:
• 多个线程可以同时读取不同的值
• 一个线程修改某个值时，其他线程仍可读取其他值
• 修改Vec结构时独占访问

Implementations

impl<V> SyncVec<V>

pub fn new_arc() -> Arc<Self>

pub const fn new() -> Self

pub fn with_vec(vec: Vec<V>) -> Self

pub fn with_capacity(capacity: usize) -> Self

pub fn insert(&self, index: usize, v: V)

pub fn push(&self, v: V)

pub fn push_return(&self, v: V) -> usize

pub fn push_vec(&self, input_arr: Vec<V>)

pub fn pop(&self) -> Option<V>

pub fn remove(&self, index: usize) -> Option<V>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn clear(&self)

pub fn shrink_to_fit(&self)

pub fn get(&self, index: usize) -> Option<RefGuard<'_, V>>

Get a reference to the value at index, protected by Vec read lock (value no lock) 获取索引处的值引用，使用Vec读锁 (值无锁)

Safety

此方法绕过了保护值的 RwLock，仅当您确定没有其他线程正在修改该值时才应使用它。 This method bypasses the RwLock protecting the value. It should only be used when you are sure that no other thread is modifying the value.

pub fn get_uncheck(&self, index: usize) -> RefGuard<'_, V>

Get a reference to the value at index (unchecked), protected by Vec read lock (value no lock) 获取索引处的值引用（无检查），使用Vec读锁 (值无锁)

Safety

此方法绕过了保护值的 RwLock，仅当您确定没有其他线程正在修改该值时才应使用它。 This method bypasses the RwLock protecting the value. It should only be used when you are sure that no other thread is modifying the value.

pub fn get_rlock(&self, index: usize) -> Option<ReadGuard<'_, V>>

Get a reference to the value at index, protected by Vec read lock + value read lock 获取索引处的值引用，使用Vec读锁 + 值的读锁保护

pub fn get_mut_lock(&self, index: usize) -> Option<WriteGuard<'_, V>>

Get a mutable reference to the value at index, protected by Vec read lock + value write lock 获取索引处的可变值引用，使用Vec读锁 + 值的写锁保护

pub fn get_mut(&self, index: usize) -> Option<MutRefGuard<'_, V>>

Get a mutable reference to the value at index, protected by Vec read lock (value no lock) 获取索引处的可变值引用，使用Vec读锁 (值无锁)

pub fn contains(&self, x: &V) -> bool

where V: PartialEq,

pub fn iter_rlock(&self) -> IterRLock<'_, V>

Safety; Get an iterator over the values, protected by Vec read lock + individual value read locks 安全地访问每个数据，获取迭代器，使用Vec读锁 + 各个值的读锁保护

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

不锁值，只锁Vec结构，适用于只读但不修改值的场景

Safety

此方法是不安全的，因为它绕过了保护每个值的 RwLock。 仅当您确定没有其他线程正在修改这些值时才应使用它。

This method is unsafe because it bypasses the RwLock protecting each value. It should only be used when you are sure that no other thread is modifying the values.

pub fn iter_mut_lock(&self) -> IterLock<'_, V>

Get a mutable iterator over the values, protected by Vec read lock + individual value write locks 获取可变迭代器，使用Vec读锁 + 各个值的写锁保护

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

Get a mutable iterator over the values, protected by Vec read lock (value no lock) 获取可变迭代器，使用Vec读锁 (值无锁)

Safety

此方法绕过了保护每个值的 RwLock。 仅当您确定没有其他线程正在修改这些值时才应使用它。

This method bypasses the RwLock protecting each value. It should only be used when you are sure that no other thread is modifying the values.

pub fn into_iter(self) -> IntoIter<V>

pub fn dirty_ref(&self) -> RefGuard<'_, Vec<RwLock<V>>>

pub fn into_inner(self) -> Vec<V>

pub fn to_vec(&self) -> Vec<V>

where V: Clone,

Trait Implementations

impl<V: Clone> Clone for SyncVec<V>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<V> Debug for SyncVec<V>

where V: Debug,

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

Formats the value using the given formatter.

impl<V> Default for SyncVec<V>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, V> Deserialize<'de> for SyncVec<V>

where 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<V: Display> Display for SyncVec<V>

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

Formats the value using the given formatter.

impl<V> Extend<V> for SyncVec<V>

fn extend<T: IntoIterator<Item = V>>(&mut self, iter: T)

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<V> From<Vec<V>> for SyncVec<V>

fn from(v: Vec<V>) -> Self

Converts to this type from the input type.

impl<V> FromIterator<V> for SyncVec<V>

fn from_iter<T: IntoIterator<Item = V>>(iter: T) -> Self

Creates a value from an iterator.

impl<V> Index<usize> for SyncVec<V>

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

Get a reference to the value at index, bypassing the lock. 获取索引处的值引用，绕过锁。

Safety

This method is unsafe because it bypasses the RwLock protecting the value. It should only be used when you are sure that no other thread is modifying the value. Concurrent access using this method is undefined behavior.

安全性

此方法是不安全的，因为它绕过了保护值的 RwLock。 仅当您确定没有其他线程正在修改该值时才应使用它。 使用此方法进行并发访问是未定义行为。

type Output = V

The returned type after indexing.

impl<V> IndexMut<usize> for SyncVec<V>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<'a, V> IntoIterator for &'a SyncVec<V>

type Item = &'a V

The type of the elements being iterated over.

type IntoIter = Iter<'a, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, V> IntoIterator for &'a mut SyncVec<V>

type Item = &'a mut V

The type of the elements being iterated over.

type IntoIter = IterMut<'a, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<V> IntoIterator for SyncVec<V>

type Item = V

The type of the elements being iterated over.

type IntoIter = IntoIter<V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<V: PartialEq> PartialEq for SyncVec<V>

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<V> Serialize for SyncVec<V>

where 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<V> Send for SyncVec<V>

This is safe, dirty mutex ensures safety 这是安全的，dirty 互斥锁保证了安全性

impl<V> Sync for SyncVec<V>

This is safe, dirty mutex ensures safety 这是安全的，dirty 互斥锁保证了安全性