Arc para Estado Compartilhado

Arc (atomically reference counted) permite que múltiplas threads compartilhem a propriedade da mesma alocação no heap. Combine-o com Mutex, RwLock ou atômicos quando as threads precisarem do mesmo estado.

Receita

Cartão de referência rápida - pronto para copiar e colar.

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();
}

Quando usar isso: Múltiplas threads precisam de acesso de longa duração à mesma configuração, cache ou contador.

Exemplo de Trabalho

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();
}

O que isso demonstra:

• Arc::clone incrementa a contagem de referências, não faz clone profundo dos dados.
• RwLock protege o Config interno para leitores e escritores.
• Cada thread obtém seu próprio handle Arc via move.

Mergulho Profundo

Como Funciona

• Contagem de referências: Arc::clone é barato (incremento atômico). Os dados são liberados quando o último Arc é descartado.
• Imutabilidade do próprio Arc: Você não pode obter &mut T de Arc<T> sem mutabilidade interior (Mutex, RwLock, atômicos).
• Segurança de thread: Arc é Send + Sync quando T: Send + Sync.
• Referências fracas: Arc::downgrade cria Weak para quebrar ciclos (callbacks, grafos).

Composições Comuns

Notas de Rust

// Clone barato - prefira Arc::clone(&x) em vez de x.clone() para clareza
let a = Arc::new(vec![1, 2, 3]);
let b = Arc::clone(&a);
 
// Weak quebra ciclos de Arc
use std::sync::Weak;
let weak: Weak<Vec<i32>> = Arc::downgrade(&a);

• Não confunda Arc::clone com clonar os dados internos.
• Para compartilhamento em uma única thread, use Rc (mais barato, não Send).
• Em código assíncrono, Arc é o padrão para estado compartilhado da aplicação em manipuladores Axum.

Armadilhas

• Clone profundo por engano - (*arc).clone() clona o T interno, não o Arc. Correção: Use Arc::clone(&arc) para outro handle.
• Arc sem mutabilidade interior - Não é possível mutar apenas através de Arc<T>. Correção: Adicione Mutex, RwLock, ou o padrão rebuild-and-swap.
• Lock mantido em Arc entre await - Tarefas assíncronas precisam de Send; guards de mutex não são. Correção: Use tokio::sync::Mutex e blocos escopados.
• Vazamentos de memória via ciclos de Arc - O pai mantém Arc<Filho> e o filho mantém Arc<Pai>. Correção: Use Weak em um dos lados.
• Estado compartilhado demais - Tudo em um único Arc<Mutex<App>> serializa o mundo. Correção: Particione o estado ou use atores/canais.

Alternativas

FAQs

Relacionado

• Mutex & RwLock - mutabilidade interior
• Send & Sync - limites de thread do Arc
• Canais - alternativa ao estado Arc compartilhado
• Estado Compartilhado em Async - Arc em Tokio
• Melhores Práticas de Concorrência - compartilhe com cuidado

Versões da Stack: Esta página foi escrita para Rust 1.97.0 (edição 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, e Polars 0.46+.