Module alloc::arc [] [src]

Threadsafe reference-counted boxes (the Arc<T>`Arc` type).

The Arc<T>`Arctype provides shared ownership of an immutable value. Destruction is deterministic, and will occur as soon as the last owner is gone. It is marked as` type provides shared ownership of an immutable value. Destruction is deterministic, and will occur as soon as the last owner is gone. It is marked as Send`Send` because it uses atomic reference counting.

If you do not need thread-safety, and just need shared ownership, consider the Rc<T>`Rc` type. It is the same as Arc<T>`Arc`, but does not use atomics, making it both thread-unsafe as well as significantly faster when updating the reference count.

The downgrade`downgrademethod can be used to create a non-owning` method can be used to create a non-owning Weak<T>`Weakpointer to the box. A` pointer to the box. A Weak<T>`Weakpointer can be upgraded to an` pointer can be upgraded to an Arc<T>`Arcpointer, but will return` pointer, but will return None`None` if the value has already been dropped.

For example, a tree with parent pointers can be represented by putting the nodes behind strong Arc<T>`Arcpointers, and then storing the parent pointers as` pointers, and then storing the parent pointers as Weak<T>`Weak` pointers.

Examples

Sharing some immutable data between threads:

use std::sync::Arc;
use std::thread;

let five = Arc::new(5);

for _ in 0..10 {
    let five = five.clone();

    thread::spawn(move || {
        println!("{:?}", five);
    });
}

Sharing mutable data safely between threads with a Mutex`Mutex`:

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

let five = Arc::new(Mutex::new(5));

for _ in 0..10 {
    let five = five.clone();

    thread::spawn(move || {
        let mut number = five.lock().unwrap();

        *number += 1;

        println!("{}", *number); // prints 6
    });
}

Structs

Arc

An atomically reference counted wrapper for shared state.

Weak [Unstable]

A weak pointer to an Arc`Arc`.

Functions

get_mut [Unstable]

Returns a mutable reference to the contained value if the Arc<T>`Arc` is unique.

strong_count [Unstable]

Get the number of strong references to this value.

weak_count [Unstable]

Get the number of weak references to this value.