Lição 44: Send e Sync Traits (Protocolo de Segurança)

1. Narrativa

Nem todo componente do mecha pode ser transferido entre cabinas. Alguns sistemas são exclusivos de uma cabina (armas ligadas por cabo), outros podem ser duplicados (sensores). O protocolo de segurança do compilador usa as traits Send e Sync para garantir que apenas dados seguros cruzam fronteiras entre threads. Se o compilador aprovar, é seguro. Se não, há risco real.

2. Conceito

Send e Sync são marker traits (sem métodos) que o compilador usa para garantir segurança em concorrência:

• Send: O tipo pode ser transferido (moved) para outra thread com segurança
• Sync: O tipo pode ser referenciado (&T) por múltiplas threads simultaneamente
• T: Sync implica que &T: Send — referências a tipos Sync podem cruzar threads
• Tipos compostos são Send/Sync automaticamente se todos os campos forem
• Tipos que NÃO são Send: Rc<T> (referência contada não atômica — use Arc<T>)
• Tipos que NÃO são Sync: Cell<T>, RefCell<T> (interior mutability não thread-safe)
• Nota: Cell<T> e RefCell<T> são Send quando T: Send, mas NÃO são Sync (mutabilidade interior sem sincronização)

3. Requisitos

• Verificar se tipos são Send e Sync
• Entender quando tipos perdem Send/Sync
• Usar Arc<T> (que exige T: Send + Sync) corretamente
• Criar wrappers que recebem Send/Sync automaticamente de T

4. Design de Dados

graph LR
    A[Send] --> B[Pode mover para outra thread]
    C[Sync] --> D[Pode compartilhar &T entre threads]
    B --> E[Thread-safe]
    D --> E

5. Diagrama de Fluxo

flowchart TD
    A[Dado] --> B{T: Send?}
    B -->|Sim| C[Pode mover para thread]
    B -->|Não| D[Erro de compilação]
    C --> E{T: Sync?}
    E -->|Sim| F[Pode compartilhar &T]
    E -->|Não| G[Use Mutex/Arc para proteger]
    F --> H[Seguro entre threads]
    G --> H

6. Funções

Função	Descrição
verificar_send	Verifica se um tipo é Send
verificar_sync	Verifica se um tipo é Sync
enviar_para_thread	Move valor para thread (requer Send)
compartilhar_entre_threads	Compartilha referência entre threads (requer Sync)
wrapper_send_sync	Cria wrapper Seguro<T> que herda Send+Sync de T
coletar_em_paralelo	Usa tipos Send para coletar resultados
mapear_em_paralelo	Transforma dados em paralelo exigindo Send
reduzir_em_paralelo	Reduz dados em paralelo exigindo Send + Sync

7. Exemplo

fn requer_send<T: Send + 'static>(valor: T) {
    // Se compila, T é Send (e 'static, exigido por thread::spawn)
    std::thread::spawn(move || {
        let _ = valor;
    });
}

// i32, String, Vec<T: Send> — todos são Send
requer_send(42i32);
requer_send(String::from("seguro"));

8. Missão

1. Implementar verificar_send com trait bound T: Send
2. Implementar verificar_sync com trait bound T: Sync
3. Implementar enviar_para_thread que move dado para thread
4. Implementar compartilhar_entre_threads usando Arc com bound Sync
5. Implementar wrapper_send_sync com struct wrapper que herda Send/Sync de T
6. Implementar coletar_em_paralelo exigindo T: Send
7. Implementar mapear_em_paralelo com transformação paralela
8. Implementar reduzir_em_paralelo com T: Send + Sync

9. Como Executar

cargo build
cargo test
cargo clippy -- -D warnings
cargo fmt --check

10. Dicas

• Quase todos os tipos em Rust são Send e Sync automaticamente
• Rc<T> NÃO é Send — use Arc<T> para compartilhamento entre threads
• RefCell<T> NÃO é Sync — use Mutex<T> ou RwLock<T>
• unsafe impl Send/Sync existe, mas requer garantias manuais de segurança
• Raw pointers (*const T, *mut T) NÃO são Send nem Sync