Struct OnionObjectCell

Source

pub struct OnionObjectCell(pub RwLock<OnionObject>);

Expand description

Onion 对象单元格。

线程安全的对象容器，使用读写锁保护内部对象，确保并发访问的安全性。是 GC 系统中对象存储的基本单位。

§设计原则

严格的幂等性检查：Cell 中不应包含 Mut 对象
线程安全的读写操作
GC 跟踪与弱引用支持

§关键方法

with_data(): 安全地访问内部对象
with_data_mut(): 安全地可变访问内部对象
with_attribute(): 属性访问代理

Tuple Fields§

§0: RwLock<OnionObject>

Implementations§

Source §

impl OnionObjectCell

Source

pub fn with_data<T, F>(&self, f: F) -> Result<T, RuntimeError>
where F: FnOnce(&OnionObject) -> Result<T, RuntimeError>,

安全地访问内部对象数据。

获取对象的只读访问权限，并执行提供的闭包。包含严格的幂等性检查，确保 Cell 中不包含 Mut 对象。

§参数

f: 处理对象的闭包

§返回

闭包的执行结果

§错误

BorrowError: 无法获取读锁
Panic: 如果 Cell 中包含 Mut 对象（表示 VM 逻辑错误）

Source

pub fn with_data_mut<T, F>(&self, f: F) -> Result<T, RuntimeError>
where F: FnOnce(&mut OnionObject) -> Result<T, RuntimeError>,

安全地可变访问内部对象数据。

获取对象的可写访问权限，并执行提供的闭包。同样包含严格的幂等性检查。

§参数

f: 处理对象的可变闭包

§返回

闭包的执行结果

§错误

BorrowError: 无法获取写锁
Panic: 如果 Cell 中包含 Mut 对象

Source

pub fn with_attribute<T, F>( &self, key: &OnionObject, f: &F, ) -> Result<T, RuntimeError>
where F: Fn(&OnionObject) -> Result<T, RuntimeError>,

属性访问代理。

通过内部对象的 with_attribute 方法访问属性。

§参数

key: 属性键对象
f: 处理属性值的闭包

Source

pub fn upgrade(&self, collected: &mut Vec<GCArc<OnionObjectCell>>)

升级对象的弱引用为强引用。

用于 GC 跟踪，防止对象被提前回收。

Source

pub fn stabilize(self) -> OnionStaticObject

稳定化对象为静态对象。

将 Cell 中的对象转换为 OnionStaticObject，用于跨函数调用和长期存储。

Source

pub fn equals(&self, other: &Self) -> Result<bool, RuntimeError>

Source

pub fn repr( &self, ptrs: &Vec<*const OnionObject>, ) -> Result<String, RuntimeError>

Source

pub fn try_borrow( &self, ) -> Result<RwLockReadGuard<'_, OnionObject>, RuntimeError>

Source

pub fn try_borrow_mut( &self, ) -> Result<RwLockWriteGuard<'_, OnionObject>, RuntimeError>

Methods from Deref<Target = RwLock<OnionObject>>§

Source

pub fn get_cloned(&self) -> Result<T, PoisonError<()>>
where T: Clone,

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

Returns the contained value by cloning it.

§Errors

This function will return an error if the RwLock is poisoned. An RwLock is poisoned whenever a writer panics while holding an exclusive lock.

§Examples

#![feature(lock_value_accessors)]

use std::sync::RwLock;

let mut lock = RwLock::new(7);

assert_eq!(lock.get_cloned().unwrap(), 7);

Source

pub fn set(&self, value: T) -> Result<(), PoisonError<T>>

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

Sets the contained value.

§Errors

This function will return an error containing the provided value if the RwLock is poisoned. An RwLock is poisoned whenever a writer panics while holding an exclusive lock.

§Examples

#![feature(lock_value_accessors)]

use std::sync::RwLock;

let mut lock = RwLock::new(7);

assert_eq!(lock.get_cloned().unwrap(), 7);
lock.set(11).unwrap();
assert_eq!(lock.get_cloned().unwrap(), 11);

Source

pub fn replace(&self, value: T) -> Result<T, PoisonError<T>>

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

Replaces the contained value with value, and returns the old contained value.

§Errors

This function will return an error containing the provided value if the RwLock is poisoned. An RwLock is poisoned whenever a writer panics while holding an exclusive lock.

§Examples

#![feature(lock_value_accessors)]

use std::sync::RwLock;

let mut lock = RwLock::new(7);

assert_eq!(lock.replace(11).unwrap(), 7);
assert_eq!(lock.get_cloned().unwrap(), 11);

1.0.0 · Source

pub fn read( &self, ) -> Result<RwLockReadGuard<'_, T>, PoisonError<RwLockReadGuard<'_, T>>>

Locks this RwLock with shared read access, blocking the current thread until it can be acquired.

The calling thread will be blocked until there are no more writers which hold the lock. There may be other readers currently inside the lock when this method returns. This method does not provide any guarantees with respect to the ordering of whether contentious readers or writers will acquire the lock first.

Returns an RAII guard which will release this thread’s shared access once it is dropped.

§Errors

This function will return an error if the RwLock is poisoned. An RwLock is poisoned whenever a writer panics while holding an exclusive lock. The failure will occur immediately after the lock has been acquired. The acquired lock guard will be contained in the returned error.

§Panics

This function might panic when called if the lock is already held by the current thread.

§Examples

use std::sync::{Arc, RwLock};
use std::thread;

let lock = Arc::new(RwLock::new(1));
let c_lock = Arc::clone(&lock);

let n = lock.read().unwrap();
assert_eq!(*n, 1);

thread::spawn(move || {
    let r = c_lock.read();
    assert!(r.is_ok());
}).join().unwrap();

1.0.0 · Source

pub fn try_read( &self, ) -> Result<RwLockReadGuard<'_, T>, TryLockError<RwLockReadGuard<'_, T>>>

Attempts to acquire this RwLock with shared read access.

If the access could not be granted at this time, then Err is returned. Otherwise, an RAII guard is returned which will release the shared access when it is dropped.

This function does not block.

This function does not provide any guarantees with respect to the ordering of whether contentious readers or writers will acquire the lock first.

§Errors

This function will return the Poisoned error if the RwLock is poisoned. An RwLock is poisoned whenever a writer panics while holding an exclusive lock. Poisoned will only be returned if the lock would have otherwise been acquired. An acquired lock guard will be contained in the returned error.

This function will return the WouldBlock error if the RwLock could not be acquired because it was already locked exclusively.

§Examples

use std::sync::RwLock;

let lock = RwLock::new(1);

match lock.try_read() {
    Ok(n) => assert_eq!(*n, 1),
    Err(_) => unreachable!(),
};

1.0.0 · Source

pub fn write( &self, ) -> Result<RwLockWriteGuard<'_, T>, PoisonError<RwLockWriteGuard<'_, T>>>

Locks this RwLock with exclusive write access, blocking the current thread until it can be acquired.

This function will not return while other writers or other readers currently have access to the lock.

Returns an RAII guard which will drop the write access of this RwLock when dropped.

§Errors

This function will return an error if the RwLock is poisoned. An RwLock is poisoned whenever a writer panics while holding an exclusive lock. An error will be returned when the lock is acquired. The acquired lock guard will be contained in the returned error.

§Panics

This function might panic when called if the lock is already held by the current thread.

§Examples

use std::sync::RwLock;

let lock = RwLock::new(1);

let mut n = lock.write().unwrap();
*n = 2;

assert!(lock.try_read().is_err());

1.0.0 · Source

pub fn try_write( &self, ) -> Result<RwLockWriteGuard<'_, T>, TryLockError<RwLockWriteGuard<'_, T>>>

Attempts to lock this RwLock with exclusive write access.

If the lock could not be acquired at this time, then Err is returned. Otherwise, an RAII guard is returned which will release the lock when it is dropped.

This function does not block.

This function does not provide any guarantees with respect to the ordering of whether contentious readers or writers will acquire the lock first.

§Errors

This function will return the Poisoned error if the RwLock is poisoned. An RwLock is poisoned whenever a writer panics while holding an exclusive lock. Poisoned will only be returned if the lock would have otherwise been acquired. An acquired lock guard will be contained in the returned error.

This function will return the WouldBlock error if the RwLock could not be acquired because it was already locked.

§Examples

use std::sync::RwLock;

let lock = RwLock::new(1);

let n = lock.read().unwrap();
assert_eq!(*n, 1);

assert!(lock.try_write().is_err());

1.2.0 · Source

pub fn is_poisoned(&self) -> bool

Determines whether the lock is poisoned.

If another thread is active, the lock can still become poisoned at any time. You should not trust a false value for program correctness without additional synchronization.

§Examples

use std::sync::{Arc, RwLock};
use std::thread;

let lock = Arc::new(RwLock::new(0));
let c_lock = Arc::clone(&lock);

let _ = thread::spawn(move || {
    let _lock = c_lock.write().unwrap();
    panic!(); // the lock gets poisoned
}).join();
assert_eq!(lock.is_poisoned(), true);

1.77.0 · Source

pub fn clear_poison(&self)

Clear the poisoned state from a lock.

If the lock is poisoned, it will remain poisoned until this function is called. This allows recovering from a poisoned state and marking that it has recovered. For example, if the value is overwritten by a known-good value, then the lock can be marked as un-poisoned. Or possibly, the value could be inspected to determine if it is in a consistent state, and if so the poison is removed.

§Examples

use std::sync::{Arc, RwLock};
use std::thread;

let lock = Arc::new(RwLock::new(0));
let c_lock = Arc::clone(&lock);

let _ = thread::spawn(move || {
    let _lock = c_lock.write().unwrap();
    panic!(); // the lock gets poisoned
}).join();

assert_eq!(lock.is_poisoned(), true);
let guard = lock.write().unwrap_or_else(|mut e| {
    **e.get_mut() = 1;
    lock.clear_poison();
    e.into_inner()
});
assert_eq!(lock.is_poisoned(), false);
assert_eq!(*guard, 1);

1.6.0 · Source

pub fn get_mut(&mut self) -> Result<&mut T, PoisonError<&mut T>>

Returns a mutable reference to the underlying data.

Since this call borrows the RwLock mutably, no actual locking needs to take place – the mutable borrow statically guarantees no new locks can be acquired while this reference exists. Note that this method does not clear any previously abandoned locks (e.g., via forget() on a RwLockReadGuard or RwLockWriteGuard).

§Errors

This function will return an error containing a mutable reference to the underlying data if the RwLock is poisoned. An RwLock is poisoned whenever a writer panics while holding an exclusive lock. An error will only be returned if the lock would have otherwise been acquired.

§Examples

use std::sync::RwLock;

let mut lock = RwLock::new(0);
*lock.get_mut().unwrap() = 10;
assert_eq!(*lock.read().unwrap(), 10);

Source

pub fn data_ptr(&self) -> *mut T

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

Returns a raw pointer to the underlying data.

The returned pointer is always non-null and properly aligned, but it is the user’s responsibility to ensure that any reads and writes through it are properly synchronized to avoid data races, and that it is not read or written through after the lock is dropped.