pub struct Arc<T> where T: ?Sized, { /* fields omitted */ }
A thread-safe reference-counting pointer. 'Arc' stands for 'Atomically Reference Counted'.
The type Arc<T>
provides shared ownership of a value of type T
, allocated in the heap. Invoking clone
on Arc
produces a new pointer to the same value in the heap. When the last Arc
pointer to a given value is destroyed, the pointed-to value is also destroyed.
Shared references in Rust disallow mutation by default, and Arc
is no exception: you cannot generally obtain a mutable reference to something inside an Arc
. If you need to mutate through an Arc
, use Mutex
, RwLock
, or one of the Atomic
types.
Unlike Rc<T>
, Arc<T>
uses atomic operations for its reference counting This means that it is thread-safe. The disadvantage is that atomic operations are more expensive than ordinary memory accesses. If you are not sharing reference-counted values between threads, consider using Rc<T>
for lower overhead. Rc<T>
is a safe default, because the compiler will catch any attempt to send an Rc<T>
between threads. However, a library might choose Arc<T>
in order to give library consumers more flexibility.
Arc<T>
will implement Send
and Sync
as long as the T
implements Send
and Sync
. Why can't you put a non-thread-safe type T
in an Arc<T>
to make it thread-safe? This may be a bit counter-intuitive at first: after all, isn't the point of Arc<T>
thread safety? The key is this: Arc<T>
makes it thread safe to have multiple ownership of the same data, but it doesn't add thread safety to its data. Consider Arc<
RefCell<T>
>
. RefCell<T>
isn't Sync
, and if Arc<T>
was always Send
, Arc<
RefCell<T>
>
would be as well. But then we'd have a problem: RefCell<T>
is not thread safe; it keeps track of the borrowing count using non-atomic operations.
In the end, this means that you may need to pair Arc<T>
with some sort of std::sync
type, usually Mutex<T>
.
Weak
The downgrade
method can be used to create a non-owning Weak
pointer. A Weak
pointer can be upgrade
d to an Arc
, but this will return None
if the value has already been dropped.
A cycle between Arc
pointers will never be deallocated. For this reason, Weak
is used to break cycles. For example, a tree could have strong Arc
pointers from parent nodes to children, and Weak
pointers from children back to their parents.
Creating a new reference from an existing reference counted pointer is done using the Clone
trait implemented for Arc<T>
and Weak<T>
.
use std::sync::Arc; let foo = Arc::new(vec![1.0, 2.0, 3.0]); // The two syntaxes below are equivalent. let a = foo.clone(); let b = Arc::clone(&foo); // a and b both point to the same memory location as foo.
The Arc::clone(&from)
syntax is the most idiomatic because it conveys more explicitly the meaning of the code. In the example above, this syntax makes it easier to see that this code is creating a new reference rather than copying the whole content of foo.
Deref
behaviorArc<T>
automatically dereferences to T
(via the Deref
trait), so you can call T
's methods on a value of type Arc<T>
. To avoid name clashes with T
's methods, the methods of Arc<T>
itself are associated functions, called using function-like syntax:
use std::sync::Arc; let my_arc = Arc::new(()); Arc::downgrade(&my_arc);
Weak<T>
does not auto-dereference to T
, because the value may have already been destroyed.
Sharing some immutable data between threads:
use std::sync::Arc; use std::thread; let five = Arc::new(5); for _ in 0..10 { let five = Arc::clone(&five); thread::spawn(move || { println!("{:?}", five); }); }
Sharing a mutable AtomicUsize
:
use std::sync::Arc; use std::sync::atomic::{AtomicUsize, Ordering}; use std::thread; let val = Arc::new(AtomicUsize::new(5)); for _ in 0..10 { let val = Arc::clone(&val); thread::spawn(move || { let v = val.fetch_add(1, Ordering::SeqCst); println!("{:?}", v); }); }
See the rc
documentation for more examples of reference counting in general.
impl<T> Arc<T>
[src]
fn new(data: T) -> Arc<T>
[src]
Constructs a new Arc<T>
.
use std::sync::Arc; let five = Arc::new(5);
fn try_unwrap(this: Arc<T>) -> Result<T, Arc<T>>
Returns the contained value, if the Arc
has exactly one strong reference.
Otherwise, an Err
is returned with the same Arc
that was passed in.
This will succeed even if there are outstanding weak references.
use std::sync::Arc; let x = Arc::new(3); assert_eq!(Arc::try_unwrap(x), Ok(3)); let x = Arc::new(4); let _y = Arc::clone(&x); assert_eq!(*Arc::try_unwrap(x).unwrap_err(), 4);
impl<T> Arc<T> where
T: ?Sized,
[src]
fn into_raw(this: Arc<T>) -> *const T
Consumes the Arc
, returning the wrapped pointer.
To avoid a memory leak the pointer must be converted back to an Arc
using Arc::from_raw
.
use std::sync::Arc; let x = Arc::new(10); let x_ptr = Arc::into_raw(x); assert_eq!(unsafe { *x_ptr }, 10);
unsafe fn from_raw(ptr: *const T) -> Arc<T>
Constructs an Arc
from a raw pointer.
The raw pointer must have been previously returned by a call to a Arc::into_raw
.
This function is unsafe because improper use may lead to memory problems. For example, a double-free may occur if the function is called twice on the same raw pointer.
use std::sync::Arc; let x = Arc::new(10); let x_ptr = Arc::into_raw(x); unsafe { // Convert back to an `Arc` to prevent leak. let x = Arc::from_raw(x_ptr); assert_eq!(*x, 10); // Further calls to `Arc::from_raw(x_ptr)` would be memory unsafe. } // The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling!
fn downgrade(this: &Arc<T>) -> Weak<T>
Creates a new Weak
pointer to this value.
use std::sync::Arc; let five = Arc::new(5); let weak_five = Arc::downgrade(&five);
fn weak_count(this: &Arc<T>) -> usize
Gets the number of Weak
pointers to this value.
This method by itself is safe, but using it correctly requires extra care. Another thread can change the weak count at any time, including potentially between calling this method and acting on the result.
use std::sync::Arc; let five = Arc::new(5); let _weak_five = Arc::downgrade(&five); // This assertion is deterministic because we haven't shared // the `Arc` or `Weak` between threads. assert_eq!(1, Arc::weak_count(&five));
fn strong_count(this: &Arc<T>) -> usize
Gets the number of strong (Arc
) pointers to this value.
This method by itself is safe, but using it correctly requires extra care. Another thread can change the strong count at any time, including potentially between calling this method and acting on the result.
use std::sync::Arc; let five = Arc::new(5); let _also_five = Arc::clone(&five); // This assertion is deterministic because we haven't shared // the `Arc` between threads. assert_eq!(2, Arc::strong_count(&five));
fn ptr_eq(this: &Arc<T>, other: &Arc<T>) -> bool
Returns true if the two Arc
s point to the same value (not just values that compare as equal).
use std::sync::Arc; let five = Arc::new(5); let same_five = Arc::clone(&five); let other_five = Arc::new(5); assert!(Arc::ptr_eq(&five, &same_five)); assert!(!Arc::ptr_eq(&five, &other_five));
impl<T> Arc<T> where
T: Clone,
[src]
fn make_mut(this: &mut Arc<T>) -> &mut T
Makes a mutable reference into the given Arc
.
If there are other Arc
or Weak
pointers to the same value, then make_mut
will invoke clone
on the inner value to ensure unique ownership. This is also referred to as clone-on-write.
See also get_mut
, which will fail rather than cloning.
use std::sync::Arc; let mut data = Arc::new(5); *Arc::make_mut(&mut data) += 1; // Won't clone anything let mut other_data = Arc::clone(&data); // 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 // Now `data` and `other_data` point to different values. assert_eq!(*data, 8); assert_eq!(*other_data, 12);
impl<T> Arc<T> where
T: ?Sized,
[src]
fn get_mut(this: &mut Arc<T>) -> Option<&mut T>
Returns a mutable reference to the inner value, if there are no other Arc
or Weak
pointers to the same value.
Returns None
otherwise, because it is not safe to mutate a shared value.
See also make_mut
, which will clone
the inner value when it's shared.
use std::sync::Arc; let mut x = Arc::new(3); *Arc::get_mut(&mut x).unwrap() = 4; assert_eq!(*x, 4); let _y = Arc::clone(&x); assert!(Arc::get_mut(&mut x).is_none());
impl<T> From<Vec<T>> for Arc<[T]>
fn from(v: Vec<T>) -> Arc<[T]>
[src]
Performs the conversion.
impl From<String> for Arc<str>
fn from(v: String) -> Arc<str>
[src]
Performs the conversion.
impl<'a> From<&'a str> for Arc<str>
fn from(v: &str) -> Arc<str>
[src]
Performs the conversion.
impl<T> From<T> for Arc<T>
fn from(t: T) -> Arc<T>
[src]
Performs the conversion.
impl<T> From<Box<T>> for Arc<T> where
T: ?Sized,
fn from(v: Box<T>) -> Arc<T>
[src]
Performs the conversion.
impl<'a, T> From<&'a [T]> for Arc<[T]> where
T: Clone,
fn from(v: &[T]) -> Arc<[T]>
[src]
Performs the conversion.
impl<T, U> CoerceUnsized<Arc<U>> for Arc<T> where
T: Unsize<U> + ?Sized,
U: ?Sized,
[src]
impl<T> PartialOrd<Arc<T>> for Arc<T> where
T: PartialOrd<T> + ?Sized,
[src]
fn partial_cmp(&self, other: &Arc<T>) -> Option<Ordering>
[src]
Partial comparison for two Arc
s.
The two are compared by calling partial_cmp()
on their inner values.
use std::sync::Arc; use std::cmp::Ordering; let five = Arc::new(5); assert_eq!(Some(Ordering::Less), five.partial_cmp(&Arc::new(6)));
fn lt(&self, other: &Arc<T>) -> bool
[src]
Less-than comparison for two Arc
s.
The two are compared by calling <
on their inner values.
use std::sync::Arc; let five = Arc::new(5); assert!(five < Arc::new(6));
fn le(&self, other: &Arc<T>) -> bool
[src]
'Less than or equal to' comparison for two Arc
s.
The two are compared by calling <=
on their inner values.
use std::sync::Arc; let five = Arc::new(5); assert!(five <= Arc::new(5));
fn gt(&self, other: &Arc<T>) -> bool
[src]
Greater-than comparison for two Arc
s.
The two are compared by calling >
on their inner values.
use std::sync::Arc; let five = Arc::new(5); assert!(five > Arc::new(4));
fn ge(&self, other: &Arc<T>) -> bool
[src]
'Greater than or equal to' comparison for two Arc
s.
The two are compared by calling >=
on their inner values.
use std::sync::Arc; let five = Arc::new(5); assert!(five >= Arc::new(5));
impl<T> PartialEq<Arc<T>> for Arc<T> where
T: PartialEq<T> + ?Sized,
[src]
fn eq(&self, other: &Arc<T>) -> bool
[src]
Equality for two Arc
s.
Two Arc
s are equal if their inner values are equal.
use std::sync::Arc; let five = Arc::new(5); assert!(five == Arc::new(5));
fn ne(&self, other: &Arc<T>) -> bool
[src]
Inequality for two Arc
s.
Two Arc
s are unequal if their inner values are unequal.
use std::sync::Arc; let five = Arc::new(5); assert!(five != Arc::new(6));
impl<T> Drop for Arc<T> where
T: ?Sized,
[src]
fn drop(&mut self)
[src]
Drops the Arc
.
This will decrement the strong reference count. If the strong reference count reaches zero then the only other references (if any) are Weak
, so we drop
the inner value.
use std::sync::Arc; struct Foo; impl Drop for Foo { fn drop(&mut self) { println!("dropped!"); } } let foo = Arc::new(Foo); let foo2 = Arc::clone(&foo); drop(foo); // Doesn't print anything drop(foo2); // Prints "dropped!"
impl<T> Send for Arc<T> where
T: Send + Sync + ?Sized,
[src]
impl<T> Default for Arc<T> where
T: Default,
[src]
fn default() -> Arc<T>
[src]
Creates a new Arc<T>
, with the Default
value for T
.
use std::sync::Arc; let x: Arc<i32> = Default::default(); assert_eq!(*x, 0);
impl<T> Debug for Arc<T> where
T: Debug + ?Sized,
[src]
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
Formats the value using the given formatter. Read more
impl<T> Borrow<T> for Arc<T> where
T: ?Sized,
[src]
fn borrow(&self) -> &T
[src]
Immutably borrows from an owned value. Read more
impl<T> Hash for Arc<T> where
T: Hash + ?Sized,
[src]
fn hash<H>(&self, state: &mut H) where
H: Hasher,
[src]
Feeds this value into the given [Hasher
]. Read more
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
Feeds a slice of this type into the given [Hasher
]. Read more
impl<T> Sync for Arc<T> where
T: Send + Sync + ?Sized,
[src]
impl<T> AsRef<T> for Arc<T> where
T: ?Sized,
fn as_ref(&self) -> &T
[src]
Performs the conversion.
impl<T> Deref for Arc<T> where
T: ?Sized,
[src]
type Target = T
The resulting type after dereferencing.
fn deref(&self) -> &T
[src]
Dereferences the value.
impl<T> Clone for Arc<T> where
T: ?Sized,
[src]
fn clone(&self) -> Arc<T>
[src]
Makes a clone of the Arc
pointer.
This creates another pointer to the same inner value, increasing the strong reference count.
use std::sync::Arc; let five = Arc::new(5); Arc::clone(&five);
fn clone_from(&mut self, source: &Self)
[src]
Performs copy-assignment from source
. Read more
impl<T> Eq for Arc<T> where
T: Eq + ?Sized,
[src]
impl<T> Pointer for Arc<T> where
T: ?Sized,
[src]
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
Formats the value using the given formatter.
impl<T> Display for Arc<T> where
T: Display + ?Sized,
[src]
fn fmt(&self, f: &mut Formatter) -> Result<(), Error>
[src]
Formats the value using the given formatter. Read more
impl<T> Ord for Arc<T> where
T: Ord + ?Sized,
[src]
fn cmp(&self, other: &Arc<T>) -> Ordering
[src]
Comparison for two Arc
s.
The two are compared by calling cmp()
on their inner values.
use std::sync::Arc; use std::cmp::Ordering; let five = Arc::new(5); assert_eq!(Ordering::Less, five.cmp(&Arc::new(6)));
fn max(self, other: Self) -> Self
Compares and returns the maximum of two values. Read more
fn min(self, other: Self) -> Self
Compares and returns the minimum of two values. Read more
impl<T: RefUnwindSafe + ?Sized> UnwindSafe for Arc<T>
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/sync/struct.Arc.html