Arc for Shared State

Arc (atomically reference counted) lets multiple threads share ownership of the same heap allocation. Combine it with Mutex, RwLock, or atomics when threads need the same state.

Recipe

Quick-reference recipe card - copy-paste ready.

use std::sync::{Arc, Mutex};
use std::thread;
 
fn main() {
    let shared = Arc::new(Mutex::new(0));
    let handle = thread::spawn({
        let shared = Arc::clone(&shared);
        move || {
            *shared.lock().unwrap() += 1;
        }
    });
    handle.join().unwrap();
}

When to reach for this: Multiple threads need long-lived access to the same configuration, cache, or counter.

Working Example

use std::sync::{Arc, RwLock};
use std::thread;
 
struct Config {
    api_url: String,
    timeout_ms: u64,
}
 
fn main() {
    let config = Arc::new(RwLock::new(Config {
        api_url: "https://api.example.com".into(),
        timeout_ms: 5000,
    }));
 
    let reader = {
        let config = Arc::clone(&config);
        thread::spawn(move || {
            let cfg = config.read().unwrap();
            println!("timeout = {}", cfg.timeout_ms);
        })
    };
 
    let writer = {
        let config = Arc::clone(&config);
        thread::spawn(move || {
            let mut cfg = config.write().unwrap();
            cfg.timeout_ms = 3000;
        })
    };
 
    reader.join().unwrap();
    writer.join().unwrap();
}

What this demonstrates:

• Arc::clone increments ref count, not deep clone of data.
• RwLock protects inner Config for readers and writers.
• Each thread gets its own Arc handle via move.

Deep Dive

How It Works

• Reference counting: Arc::clone is cheap (atomic increment). Data is freed when the last Arc drops.
• Immutability of Arc itself: You cannot get &mut T from Arc<T> without interior mutability (Mutex, RwLock, atomics).
• Thread safety: Arc is Send + Sync when T: Send + Sync.
• Weak references: Arc::downgrade creates Weak to break cycles (callbacks, graphs).

Common Compositions

Rust Notes

// Cheap clone - prefer Arc::clone(&x) over x.clone() for clarity
let a = Arc::new(vec![1, 2, 3]);
let b = Arc::clone(&a);
 
// Weak breaks Arc cycles
use std::sync::Weak;
let weak: Weak<Vec<i32>> = Arc::downgrade(&a);

• Do not confuse Arc::clone with cloning inner data.
• For single-thread sharing, use Rc (cheaper, not Send).
• In async, Arc is the default for shared app state in Axum handlers.

Gotchas

• Deep clone by mistake - (*arc).clone() clones inner T, not the Arc. Fix: Use Arc::clone(&arc) for another handle.
• Arc without interior mutability - Cannot mutate through Arc<T> alone. Fix: Add Mutex, RwLock, or rebuild-and-swap pattern.
• Lock held in Arc across await - Async tasks need Send; mutex guards are not. Fix: Use tokio::sync::Mutex and scoped blocks.
• Memory leaks via Arc cycles - Parent holds Arc<Child> and child holds Arc<Parent>. Fix: Use Weak on one side.
• Too much shared state - Everything in one Arc<Mutex<App>> serializes the world. Fix: Shard state or use actors/channels.

Alternatives

FAQs

Related

• Mutex & RwLock - interior mutability
• Send & Sync - Arc thread bounds
• Channels - alternative to shared Arc state
• Shared State in Async - Arc in Tokio
• Concurrency Best Practices - share carefully

Stack versions: This page was written for Rust 1.97.0 (edition 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, and Polars 0.46+.