Struct alloc::arc::Arc
[−]
[src]
pub struct Arc<T: ?Sized> {
// some fields omitted
}1.0.0An atomically reference counted wrapper for shared state.
Examples
In this example, a large vector is shared between several threads.
With simple pipes, without Arc, a copy would have to be made for each
thread.
When you clone an Arc<T>, it will create another pointer to the data and
increase the reference counter.
use std::sync::Arc; use std::thread; fn main() { let numbers: Vec<_> = (0..100).collect(); let shared_numbers = Arc::new(numbers); for _ in 0..10 { let child_numbers = shared_numbers.clone(); thread::spawn(move || { let local_numbers = &child_numbers[..]; // Work with the local numbers }); } }
Methods
impl<T> Arc<T>
fn new(data: T) -> Arc<T>
fn try_unwrap(this: Self) -> Result<T, Self>1.4.0
Unwraps the contained value if the Arc<T> has exactly one strong reference.
Otherwise, an Err is returned with the same Arc<T>.
This will succeed even if there are outstanding weak references.
Examples
use std::sync::Arc; let x = Arc::new(3); assert_eq!(Arc::try_unwrap(x), Ok(3)); let x = Arc::new(4); let _y = x.clone(); assert_eq!(Arc::try_unwrap(x), Err(Arc::new(4)));
impl<T: ?Sized> Arc<T>
fn downgrade(this: &Self) -> Weak<T>1.4.0
Downgrades the Arc<T> to a Weak<T> reference.
Examples
use std::sync::Arc; let five = Arc::new(5); let weak_five = Arc::downgrade(&five);
fn weak_count(this: &Self) -> usize
Get the number of weak references to this value.
fn strong_count(this: &Self) -> usize
Get the number of strong references to this value.
impl<T: Clone> Arc<T>
fn make_mut(this: &mut Self) -> &mut T1.4.0
Make a mutable reference into the given Arc<T>.
If the Arc<T> has more than one strong reference, or any weak
references, the inner data is cloned.
This is also referred to as a copy-on-write.
Examples
use std::sync::Arc; let mut data = Arc::new(5); *Arc::make_mut(&mut data) += 1; // Won't clone anything let mut other_data = data.clone(); // Won't clone inner data *Arc::make_mut(&mut data) += 1; // Clones inner data *Arc::make_mut(&mut data) += 1; // Won't clone anything *Arc::make_mut(&mut other_data) *= 2; // Won't clone anything // Note: data and other_data now point to different numbers assert_eq!(*data, 8); assert_eq!(*other_data, 12);
impl<T: ?Sized> Arc<T>
fn get_mut(this: &mut Self) -> Option<&mut T>1.4.0
Returns a mutable reference to the contained value if the Arc<T> has
one strong reference and no weak references.
Examples
use std::sync::Arc; let mut x = Arc::new(3); *Arc::get_mut(&mut x).unwrap() = 4; assert_eq!(*x, 4); let _y = x.clone(); assert!(Arc::get_mut(&mut x).is_none());
Trait Implementations
impl<T: ?Sized + Sync + Send> Send for Arc<T>
impl<T: ?Sized + Sync + Send> Sync for Arc<T>
impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<Arc<U>> for Arc<T>
impl<T: ?Sized> Clone for Arc<T>
fn clone(&self) -> Arc<T>
Makes a clone of the Arc<T>.
This increases the strong reference count.
Examples
use std::sync::Arc; let five = Arc::new(5); five.clone();
fn clone_from(&mut self, source: &Self)
impl<T: ?Sized> Deref for Arc<T>
impl<T: ?Sized> Drop for Arc<T>
fn drop(&mut self)
Drops the Arc<T>.
This will decrement the strong reference count. If the strong reference
count becomes zero and the only other references are Weak<T> ones,
drops the inner value.
Examples
use std::sync::Arc; { let five = Arc::new(5); // stuff drop(five); // explicit drop } { let five = Arc::new(5); // stuff } // implicit drop
impl<T: ?Sized + PartialEq> PartialEq for Arc<T>
fn eq(&self, other: &Arc<T>) -> bool
Equality for two Arc<T>s.
Two Arc<T>s are equal if their inner value are equal.
Examples
use std::sync::Arc; let five = Arc::new(5); five == Arc::new(5);
fn ne(&self, other: &Arc<T>) -> bool
Inequality for two Arc<T>s.
Two Arc<T>s are unequal if their inner value are unequal.
Examples
use std::sync::Arc; let five = Arc::new(5); five != Arc::new(5);
impl<T: ?Sized + PartialOrd> PartialOrd for Arc<T>
fn partial_cmp(&self, other: &Arc<T>) -> Option<Ordering>
Partial comparison for two Arc<T>s.
The two are compared by calling partial_cmp() on their inner values.
Examples
use std::sync::Arc; let five = Arc::new(5); five.partial_cmp(&Arc::new(5));
fn lt(&self, other: &Arc<T>) -> bool
Less-than comparison for two Arc<T>s.
The two are compared by calling < on their inner values.
Examples
use std::sync::Arc; let five = Arc::new(5); five < Arc::new(5);
fn le(&self, other: &Arc<T>) -> bool
'Less-than or equal to' comparison for two Arc<T>s.
The two are compared by calling <= on their inner values.
Examples
use std::sync::Arc; let five = Arc::new(5); five <= Arc::new(5);
fn gt(&self, other: &Arc<T>) -> bool
Greater-than comparison for two Arc<T>s.
The two are compared by calling > on their inner values.
Examples
use std::sync::Arc; let five = Arc::new(5); five > Arc::new(5);
fn ge(&self, other: &Arc<T>) -> bool
'Greater-than or equal to' comparison for two Arc<T>s.
The two are compared by calling >= on their inner values.
Examples
use std::sync::Arc; let five = Arc::new(5); five >= Arc::new(5);